fix: handle empty documents list in KnowledgeStorage.save() and asave()

Fixes #4277

When KnowledgeStorage.save() or asave() is called with an empty documents
list, the method now returns early instead of propagating a low-level
ValueError from ChromaDB's upsert operation.

This is a valid edge case that can occur in real-world workflows (e.g.,
after filtering, retrieval failures, or conditional logic), and should
be handled gracefully as a no-op.

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

.github/workflows/generate-tool-specs.yml

@@ -1,63 +0,0 @@
-name: Generate Tool Specifications
-
-on:
-  pull_request:
-    branches:
-      - main
-    paths:
-      - 'lib/crewai-tools/src/crewai_tools/**'
-  workflow_dispatch:
-
-permissions:
-  contents: write
-  pull-requests: write
-
-jobs:
-  generate-specs:
-    runs-on: ubuntu-latest
-    env:
-      PYTHONUNBUFFERED: 1
-
-    steps:
-      - name: Generate GitHub App token
-        id: app-token
-        uses: tibdex/github-app-token@v2
-        with:
-          app_id: ${{ secrets.CREWAI_TOOL_SPECS_APP_ID }}
-          private_key: ${{ secrets.CREWAI_TOOL_SPECS_PRIVATE_KEY }}
-
-      - name: Checkout code
-        uses: actions/checkout@v4
-        with:
-          ref: ${{ github.head_ref }}
-          token: ${{ steps.app-token.outputs.token }}
-
-      - name: Install uv
-        uses: astral-sh/setup-uv@v6
-        with:
-          version: "0.8.4"
-          python-version: "3.12"
-          enable-cache: true
-
-      - name: Install the project
-        working-directory: lib/crewai-tools
-        run: uv sync --dev --all-extras
-
-      - name: Generate tool specifications
-        working-directory: lib/crewai-tools
-        run: uv run python src/crewai_tools/generate_tool_specs.py
-
-      - name: Check for changes and commit
-        run: |
-          git config user.name "github-actions[bot]"
-          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
-
-          git add lib/crewai-tools/tool.specs.json
-
-          if git diff --quiet --staged; then
-            echo "No changes detected in tool.specs.json"
-          else
-            echo "Changes detected in tool.specs.json, committing..."
-            git commit -m "chore: update tool specifications"
-            git push
-          fi

docs/docs.json

@@ -370,8 +370,7 @@
                 "pages": [
                   "en/enterprise/features/traces",
                   "en/enterprise/features/webhook-streaming",
-                  "en/enterprise/features/hallucination-guardrail",
-                  "en/enterprise/features/flow-hitl-management"
+                  "en/enterprise/features/hallucination-guardrail"
                 ]
               },
               {
@@ -824,8 +823,7 @@
                 "pages": [
                   "pt-BR/enterprise/features/traces",
                   "pt-BR/enterprise/features/webhook-streaming",
-                  "pt-BR/enterprise/features/hallucination-guardrail",
-                  "pt-BR/enterprise/features/flow-hitl-management"
+                  "pt-BR/enterprise/features/hallucination-guardrail"
                 ]
               },
               {
@@ -1289,8 +1287,7 @@
                 "pages": [
                   "ko/enterprise/features/traces",
                   "ko/enterprise/features/webhook-streaming",
-                  "ko/enterprise/features/hallucination-guardrail",
-                  "ko/enterprise/features/flow-hitl-management"
+                  "ko/enterprise/features/hallucination-guardrail"
                 ]
               },
               {

docs/en/changelog.mdx

@@ -4,74 +4,6 @@ description: "Product updates, improvements, and bug fixes for CrewAI"
 icon: "clock"
 mode: "wide"
 ---
-<Update label="Jan 26, 2026">
-  ## v1.9.0
-
-  [View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.9.0)
-
-  ## What's Changed
-
-  ### Features
-  - Add structured outputs and response_format support across providers
-  - Add response ID to streaming responses
-  - Add event ordering with parent-child hierarchies
-  - Add Keycloak SSO authentication support
-  - Add multimodal file handling capabilities
-  - Add native OpenAI responses API support
-  - Add A2A task execution utilities
-  - Add A2A server configuration and agent card generation
-  - Enhance event system and expand transport options
-  - Improve tool calling mechanisms
-
-  ### Bug Fixes
-  - Enhance file store with fallback memory cache when aiocache is not available
-  - Ensure document list is not empty
-  - Handle Bedrock stop sequences properly
-  - Add Google Vertex API key support
-  - Enhance Azure model stop word detection
-  - Improve error handling for HumanFeedbackPending in flow execution
-  - Fix execution span task unlinking
-
-  ### Documentation
-  - Add native file handling documentation
-  - Add OpenAI responses API documentation
-  - Add agent card implementation guidance
-  - Refine A2A documentation
-  - Update changelog for v1.8.0
-
-  ### Contributors
-  @Anaisdg, @GininDenis, @Vidit-Ostwal, @greysonlalonde, @heitorado, @joaomdmoura, @koushiv777, @lorenzejay, @nicoferdi96, @vinibrsl
-
-</Update>
-
-<Update label="Jan 15, 2026">
-  ## v1.8.1
-
-  [View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.8.1)
-
-  ## What's Changed
-
-  ### Features
-  - Add A2A task execution utilities
-  - Add A2A server configuration and agent card generation
-  - Add additional transport mechanisms
-  - Add Galileo integration support
-
-  ### Bug Fixes
-  - Improve Azure model compatibility
-  - Expand frame inspection depth to detect parent_flow
-  - Resolve task execution span management issues
-  - Enhance error handling for human feedback scenarios during flow execution
-
-  ### Documentation
-  - Add A2A agent card documentation
-  - Add PII redaction feature documentation
-
-  ### Contributors
-  @Anaisdg, @GininDenis, @greysonlalonde, @joaomdmoura, @koushiv777, @lorenzejay, @vinibrsl
-
-</Update>
-
 <Update label="Jan 08, 2026">
   ## v1.8.0
 

docs/en/concepts/memory.mdx

@@ -401,58 +401,23 @@ crew = Crew(
 
 ### Vertex AI Embeddings
 
-For Google Cloud users with Vertex AI access. Supports both legacy and new embedding models with automatic SDK selection.
-
-<Note>
-**Deprecation Notice:** Legacy models (`textembedding-gecko*`) use the deprecated `vertexai.language_models` SDK which will be removed after June 24, 2026. Consider migrating to newer models like `gemini-embedding-001`. See the [Google migration guide](https://docs.cloud.google.com/vertex-ai/generative-ai/docs/deprecations/genai-vertexai-sdk) for details.
-</Note>
+For Google Cloud users with Vertex AI access.
 
 ```python
-# Recommended: Using new models with google-genai SDK
 crew = Crew(
     memory=True,
     embedder={
-        "provider": "google-vertex",
+        "provider": "vertexai",
         "config": {
             "project_id": "your-gcp-project-id",
-            "location": "us-central1",
-            "model_name": "gemini-embedding-001",  # or "text-embedding-005", "text-multilingual-embedding-002"
-            "task_type": "RETRIEVAL_DOCUMENT",  # Optional
-            "output_dimensionality": 768  # Optional
-        }
-    }
-)
-
-# Using API key authentication (Exp)
-crew = Crew(
-    memory=True,
-    embedder={
-        "provider": "google-vertex",
-        "config": {
-            "api_key": "your-google-api-key",
-            "model_name": "gemini-embedding-001"
-        }
-    }
-)
-
-# Legacy models (backwards compatible, emits deprecation warning)
-crew = Crew(
-    memory=True,
-    embedder={
-        "provider": "google-vertex",
-        "config": {
-            "project_id": "your-gcp-project-id",
-            "region": "us-central1",  # or "location" (region is deprecated)
-            "model_name": "textembedding-gecko"  # Legacy model
+            "region": "us-central1",  # or your preferred region
+            "api_key": "your-service-account-key",
+            "model_name": "textembedding-gecko"
         }
     }
 )
 ```
 
-**Available models:**
-- **New SDK models** (recommended): `gemini-embedding-001`, `text-embedding-005`, `text-multilingual-embedding-002`
-- **Legacy models** (deprecated): `textembedding-gecko`, `textembedding-gecko@001`, `textembedding-gecko-multilingual`
-
 ### Ollama Embeddings (Local)
 
 Run embeddings locally for privacy and cost savings.
@@ -604,7 +569,7 @@ mem0_client_embedder_config = {
             "project_id": "my_project_id", # Optional
             "api_key": "custom-api-key"    # Optional - overrides env var
             "run_id": "my_run_id",        # Optional - for short-term memory
-            "includes": "include1",       # Optional
+            "includes": "include1",       # Optional 
             "excludes": "exclude1",       # Optional
             "infer": True                 # Optional defaults to True
             "custom_categories": new_categories  # Optional - custom categories for user memory
@@ -626,7 +591,7 @@ crew = Crew(
 
 ### Choosing the Right Embedding Provider
 
-When selecting an embedding provider, consider factors like performance, privacy, cost, and integration needs.
+When selecting an embedding provider, consider factors like performance, privacy, cost, and integration needs.  
 Below is a comparison to help you decide:
 
 | Provider       | Best For                       | Pros                              | Cons                      |
@@ -784,7 +749,7 @@ Entity Memory supports batching when saving multiple entities at once. When you
 
 This improves performance and observability when writing many entities in one operation.
 
-## 2. External Memory
+## 2. External Memory 
 External Memory provides a standalone memory system that operates independently from the crew's built-in memory. This is ideal for specialized memory providers or cross-application memory sharing.
 
 ### Basic External Memory with Mem0
@@ -854,7 +819,7 @@ external_memory = ExternalMemory(
             "project_id": "my_project_id", # Optional
             "api_key": "custom-api-key"    # Optional - overrides env var
             "run_id": "my_run_id",        # Optional - for short-term memory
-            "includes": "include1",       # Optional
+            "includes": "include1",       # Optional 
             "excludes": "exclude1",       # Optional
             "infer": True                 # Optional defaults to True
             "custom_categories": new_categories  # Optional - custom categories for user memory

docs/en/enterprise/features/flow-hitl-management.mdx

@@ -1,563 +0,0 @@
----
-title: "Flow HITL Management"
-description: "Enterprise-grade human review for Flows with email-first notifications, routing rules, and auto-response capabilities"
-icon: "users-gear"
-mode: "wide"
----
-
-<Note>
-Flow HITL Management features require the `@human_feedback` decorator, available in **CrewAI version 1.8.0 or higher**. These features apply specifically to **Flows**, not Crews.
-</Note>
-
-CrewAI Enterprise provides a comprehensive Human-in-the-Loop (HITL) management system for Flows that transforms AI workflows into collaborative human-AI processes. The platform uses an **email-first architecture** that enables anyone with an email address to respond to review requests—no platform account required.
-
-## Overview
-
-<CardGroup cols={3}>
-  <Card title="Email-First Design" icon="envelope">
-    Responders can reply directly to notification emails to provide feedback
-  </Card>
-  <Card title="Flexible Routing" icon="route">
-    Route requests to specific emails based on method patterns or flow state
-  </Card>
-  <Card title="Auto-Response" icon="clock">
-    Configure automatic fallback responses when no human replies in time
-  </Card>
-</CardGroup>
-
-### Key Benefits
-
-- **Simple mental model**: Email addresses are universal; no need to manage platform users or roles
-- **External responders**: Anyone with an email can respond, even non-platform users
-- **Dynamic assignment**: Pull assignee email directly from flow state (e.g., `sales_rep_email`)
-- **Reduced configuration**: Fewer settings to configure, faster time to value
-- **Email as primary channel**: Most users prefer responding via email over logging into a dashboard
-
-## Setting Up Human Review Points in Flows
-
-Configure human review checkpoints within your Flows using the `@human_feedback` decorator. When execution reaches a review point, the system pauses, notifies the assignee via email, and waits for a response.
-
-```python
-from crewai.flow.flow import Flow, start, listen
-from crewai.flow.human_feedback import human_feedback, HumanFeedbackResult
-
-class ContentApprovalFlow(Flow):
-    @start()
-    def generate_content(self):
-        # AI generates content
-        return "Generated marketing copy for Q1 campaign..."
-
-    @listen(generate_content)
-    @human_feedback(
-        message="Please review this content for brand compliance:",
-        emit=["approved", "rejected", "needs_revision"],
-    )
-    def review_content(self, content):
-        return content
-
-    @listen("approved")
-    def publish_content(self, result: HumanFeedbackResult):
-        print(f"Publishing approved content. Reviewer notes: {result.feedback}")
-
-    @listen("rejected")
-    def archive_content(self, result: HumanFeedbackResult):
-        print(f"Content rejected. Reason: {result.feedback}")
-
-    @listen("needs_revision")
-    def revise_content(self, result: HumanFeedbackResult):
-        print(f"Revision requested: {result.feedback}")
-```
-
-For complete implementation details, see the [Human Feedback in Flows](/en/learn/human-feedback-in-flows) guide.
-
-### Decorator Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| `message` | `str` | The message displayed to the human reviewer |
-| `emit` | `list[str]` | Valid response options (displayed as buttons in UI) |
-
-## Platform Configuration
-
-Access HITL configuration from: **Deployment → Settings → Human in the Loop Configuration**
-
-<Frame>
-  <img src="/images/enterprise/hitl-settings-overview.png" alt="HITL Configuration Settings" />
-</Frame>
-
-### Email Notifications
-
-Toggle to enable or disable email notifications for HITL requests.
-
-| Setting | Default | Description |
-|---------|---------|-------------|
-| Email Notifications | Enabled | Send emails when feedback is requested |
-
-<Note>
-When disabled, responders must use the dashboard UI or you must configure webhooks for custom notification systems.
-</Note>
-
-### SLA Target
-
-Set a target response time for tracking and metrics purposes.
-
-| Setting | Description |
-|---------|-------------|
-| SLA Target (minutes) | Target response time. Used for dashboard metrics and SLA tracking |
-
-Leave empty to disable SLA tracking.
-
-## Email Notifications & Responses
-
-The HITL system uses an email-first architecture where responders can reply directly to notification emails.
-
-### How Email Responses Work
-
-<Steps>
-  <Step title="Notification Sent">
-    When a HITL request is created, an email is sent to the assigned responder with the review content and context.
-  </Step>
-  <Step title="Reply-To Address">
-    The email includes a special reply-to address with a signed token for authentication.
-  </Step>
-  <Step title="User Replies">
-    The responder simply replies to the email with their feedback—no login required.
-  </Step>
-  <Step title="Token Validation">
-    The platform receives the reply, verifies the signed token, and matches the sender email.
-  </Step>
-  <Step title="Flow Resumes">
-    The feedback is recorded and the flow continues with the human's input.
-  </Step>
-</Steps>
-
-### Response Format
-
-Responders can reply with:
-
-- **Emit option**: If the reply matches an `emit` option (e.g., "approved"), it's used directly
-- **Free-form text**: Any text response is passed to the flow as feedback
-- **Plain text**: The first line of the reply body is used as feedback
-
-### Confirmation Emails
-
-After processing a reply, the responder receives a confirmation email indicating whether the feedback was successfully submitted or if an error occurred.
-
-### Email Token Security
-
-- Tokens are cryptographically signed for security
-- Tokens expire after 7 days
-- Sender email must match the token's authorized email
-- Confirmation/error emails are sent after processing
-
-## Routing Rules
-
-Route HITL requests to specific email addresses based on method patterns.
-
-<Frame>
-  <img src="/images/enterprise/hitl-settings-routing-rules.png" alt="HITL Routing Rules Configuration" />
-</Frame>
-
-### Rule Structure
-
-```json
-{
-  "name": "Approvals to Finance",
-  "match": {
-    "method_name": "approve_*"
-  },
-  "assign_to_email": "finance@company.com",
-  "assign_from_input": "manager_email"
-}
-```
-
-### Matching Patterns
-
-| Pattern | Description | Example Match |
-|---------|-------------|---------------|
-| `approve_*` | Wildcard (any chars) | `approve_payment`, `approve_vendor` |
-| `review_?` | Single char | `review_a`, `review_1` |
-| `validate_payment` | Exact match | `validate_payment` only |
-
-### Assignment Priority
-
-1. **Dynamic assignment** (`assign_from_input`): If configured, pulls email from flow state
-2. **Static email** (`assign_to_email`): Falls back to configured email
-3. **Deployment creator**: If no rule matches, the deployment creator's email is used
-
-### Dynamic Assignment Example
-
-If your flow state contains `{"sales_rep_email": "alice@company.com"}`, configure:
-
-```json
-{
-  "name": "Route to Sales Rep",
-  "match": {
-    "method_name": "review_*"
-  },
-  "assign_from_input": "sales_rep_email"
-}
-```
-
-The request will be assigned to `alice@company.com` automatically.
-
-<Tip>
-**Use Case**: Pull the assignee from your CRM, database, or previous flow step to dynamically route reviews to the right person.
-</Tip>
-
-## Auto-Response
-
-Automatically respond to HITL requests if no human responds within a timeout. This ensures flows don't hang indefinitely.
-
-### Configuration
-
-| Setting | Description |
-|---------|-------------|
-| Enabled | Toggle to enable auto-response |
-| Timeout (minutes) | Time to wait before auto-responding |
-| Default Outcome | The response value (must match an `emit` option) |
-
-<Frame>
-  <img src="/images/enterprise/hitl-settings-auto-respond.png" alt="HITL Auto-Response Configuration" />
-</Frame>
-
-### Use Cases
-
-- **SLA compliance**: Ensure flows don't hang indefinitely
-- **Default approval**: Auto-approve low-risk requests after timeout
-- **Graceful degradation**: Continue with a safe default when reviewers are unavailable
-
-<Warning>
-Use auto-response carefully. Only enable it for non-critical reviews where a default response is acceptable.
-</Warning>
-
-## Review Process
-
-### Dashboard Interface
-
-The HITL review interface provides a clean, focused experience for reviewers:
-
-- **Markdown Rendering**: Rich formatting for review content with syntax highlighting
-- **Context Panel**: View flow state, execution history, and related information
-- **Feedback Input**: Provide detailed feedback and comments with your decision
-- **Quick Actions**: One-click emit option buttons with optional comments
-
-<Frame>
-  <img src="/images/enterprise/hitl-list-pending-feedbacks.png" alt="HITL Pending Requests List" />
-</Frame>
-
-### Response Methods
-
-Reviewers can respond via three channels:
-
-| Method | Description |
-|--------|-------------|
-| **Email Reply** | Reply directly to the notification email |
-| **Dashboard** | Use the Enterprise dashboard UI |
-| **API/Webhook** | Programmatic response via API |
-
-### History & Audit Trail
-
-Every HITL interaction is tracked with a complete timeline:
-
-- Decision history (approve/reject/revise)
-- Reviewer identity and timestamp
-- Feedback and comments provided
-- Response method (email/dashboard/API)
-- Response time metrics
-
-## Analytics & Monitoring
-
-Track HITL performance with comprehensive analytics.
-
-### Performance Dashboard
-
-<Frame>
-  <img src="/images/enterprise/hitl-metrics.png" alt="HITL Metrics Dashboard" />
-</Frame>
-
-<CardGroup cols={2}>
-  <Card title="Response Times" icon="stopwatch">
-    Monitor average and median response times by reviewer or flow.
-  </Card>
-  <Card title="Volume Trends" icon="chart-bar">
-    Analyze review volume patterns to optimize team capacity.
-  </Card>
-  <Card title="Decision Distribution" icon="chart-pie">
-    View approval/rejection rates across different review types.
-  </Card>
-  <Card title="SLA Tracking" icon="chart-line">
-    Track percentage of reviews completed within SLA targets.
-  </Card>
-</CardGroup>
-
-### Audit & Compliance
-
-Enterprise-ready audit capabilities for regulatory requirements:
-
-- Complete decision history with timestamps
-- Reviewer identity verification
-- Immutable audit logs
-- Export capabilities for compliance reporting
-
-## Common Use Cases
-
-<AccordionGroup>
-  <Accordion title="Security Reviews" icon="shield-halved">
-    **Use Case**: Internal security questionnaire automation with human validation
-
-    - AI generates responses to security questionnaires
-    - Security team reviews and validates accuracy via email
-    - Approved responses are compiled into final submission
-    - Full audit trail for compliance
-  </Accordion>
-
-  <Accordion title="Content Approval" icon="file-lines">
-    **Use Case**: Marketing content requiring legal/brand review
-
-    - AI generates marketing copy or social media content
-    - Route to brand team email for voice/tone review
-    - Automatic publishing upon approval
-  </Accordion>
-
-  <Accordion title="Financial Approvals" icon="money-bill">
-    **Use Case**: Expense reports, contract terms, budget allocations
-
-    - AI pre-processes and categorizes financial requests
-    - Route based on amount thresholds using dynamic assignment
-    - Maintain complete audit trail for financial compliance
-  </Accordion>
-
-  <Accordion title="Dynamic Assignment from CRM" icon="database">
-    **Use Case**: Route reviews to account owners from your CRM
-
-    - Flow fetches account owner email from CRM
-    - Store email in flow state (e.g., `account_owner_email`)
-    - Use `assign_from_input` to route to the right person automatically
-  </Accordion>
-
-  <Accordion title="Quality Assurance" icon="magnifying-glass">
-    **Use Case**: AI output validation before customer delivery
-
-    - AI generates customer-facing content or responses
-    - QA team reviews via email notification
-    - Feedback loops improve AI performance over time
-  </Accordion>
-</AccordionGroup>
-
-## Webhooks API
-
-When your Flows pause for human feedback, you can configure webhooks to send request data to your own application. This enables:
-
-- Building custom approval UIs
-- Integrating with internal tools (Jira, ServiceNow, custom dashboards)
-- Routing approvals to third-party systems
-- Mobile app notifications
-- Automated decision systems
-
-<Frame>
-  <img src="/images/enterprise/hitl-settings-webhook.png" alt="HITL Webhook Configuration" />
-</Frame>
-
-### Configuring Webhooks
-
-<Steps>
-  <Step title="Navigate to Settings">
-    Go to your **Deployment** → **Settings** → **Human in the Loop**
-  </Step>
-  <Step title="Expand Webhooks Section">
-    Click to expand the **Webhooks** configuration
-  </Step>
-  <Step title="Add Your Webhook URL">
-    Enter your webhook URL (must be HTTPS in production)
-  </Step>
-  <Step title="Save Configuration">
-    Click **Save Configuration** to activate
-  </Step>
-</Steps>
-
-You can configure multiple webhooks. Each active webhook receives all HITL events.
-
-### Webhook Events
-
-Your endpoint will receive HTTP POST requests for these events:
-
-| Event Type | When Triggered |
-|------------|----------------|
-| `new_request` | A flow pauses and requests human feedback |
-
-### Webhook Payload
-
-All webhooks receive a JSON payload with this structure:
-
-```json
-{
-  "event": "new_request",
-  "request": {
-    "id": "550e8400-e29b-41d4-a716-446655440000",
-    "flow_id": "flow_abc123",
-    "method_name": "review_article",
-    "message": "Please review this article for publication.",
-    "emit_options": ["approved", "rejected", "request_changes"],
-    "state": {
-      "article_id": 12345,
-      "author": "john@example.com",
-      "category": "technology"
-    },
-    "metadata": {},
-    "created_at": "2026-01-14T12:00:00Z"
-  },
-  "deployment": {
-    "id": 456,
-    "name": "Content Review Flow",
-    "organization_id": 789
-  },
-  "callback_url": "https://api.crewai.com/...",
-  "assigned_to_email": "reviewer@company.com"
-}
-```
-
-### Responding to Requests
-
-To submit feedback, **POST to the `callback_url`** included in the webhook payload.
-
-```http
-POST {callback_url}
-Content-Type: application/json
-
-{
-  "feedback": "Approved. Great article!",
-  "source": "my_custom_app"
-}
-```
-
-### Security
-
-<Info>
-All webhook requests are cryptographically signed using HMAC-SHA256 to ensure authenticity and prevent tampering.
-</Info>
-
-#### Webhook Security
-
-- **HMAC-SHA256 signatures**: Every webhook includes a cryptographic signature
-- **Per-webhook secrets**: Each webhook has its own unique signing secret
-- **Encrypted at rest**: Signing secrets are encrypted in our database
-- **Timestamp verification**: Prevents replay attacks
-
-#### Signature Headers
-
-Each webhook request includes these headers:
-
-| Header | Description |
-|--------|-------------|
-| `X-Signature` | HMAC-SHA256 signature: `sha256=<hex_digest>` |
-| `X-Timestamp` | Unix timestamp when the request was signed |
-
-#### Verification
-
-Verify by computing:
-
-```python
-import hmac
-import hashlib
-
-expected = hmac.new(
-    signing_secret.encode(),
-    f"{timestamp}.{payload}".encode(),
-    hashlib.sha256
-).hexdigest()
-
-if hmac.compare_digest(expected, signature):
-    # Valid signature
-```
-
-### Error Handling
-
-Your webhook endpoint should return a 2xx status code to acknowledge receipt:
-
-| Your Response | Our Behavior |
-|---------------|--------------|
-| 2xx | Webhook delivered successfully |
-| 4xx/5xx | Logged as failed, no retry |
-| Timeout (30s) | Logged as failed, no retry |
-
-## Security & RBAC
-
-### Dashboard Access
-
-HITL access is controlled at the deployment level:
-
-| Permission | Capability |
-|------------|------------|
-| `manage_human_feedback` | Configure HITL settings, view all requests |
-| `respond_to_human_feedback` | Respond to requests, view assigned requests |
-
-### Email Response Authorization
-
-For email replies:
-1. The reply-to token encodes the authorized email
-2. Sender email must match the token's email
-3. Token must not be expired (7-day default)
-4. Request must still be pending
-
-### Audit Trail
-
-All HITL actions are logged:
-- Request creation
-- Assignment changes
-- Response submission (with source: dashboard/email/API)
-- Flow resume status
-
-## Troubleshooting
-
-### Emails Not Sending
-
-1. Check "Email Notifications" is enabled in configuration
-2. Verify routing rules match the method name
-3. Verify assignee email is valid
-4. Check deployment creator fallback if no routing rules match
-
-### Email Replies Not Processing
-
-1. Check token hasn't expired (7-day default)
-2. Verify sender email matches assigned email
-3. Ensure request is still pending (not already responded)
-
-### Flow Not Resuming
-
-1. Check request status in dashboard
-2. Verify callback URL is accessible
-3. Ensure deployment is still running
-
-## Best Practices
-
-<Tip>
-**Start Simple**: Begin with email notifications to deployment creator, then add routing rules as your workflows mature.
-</Tip>
-
-1. **Use Dynamic Assignment**: Pull assignee emails from your flow state for flexible routing.
-
-2. **Configure Auto-Response**: Set up a fallback for non-critical reviews to prevent flows from hanging.
-
-3. **Monitor Response Times**: Use analytics to identify bottlenecks and optimize your review process.
-
-4. **Keep Review Messages Clear**: Write clear, actionable messages in the `@human_feedback` decorator.
-
-5. **Test Email Flow**: Send test requests to verify email delivery before going to production.
-
-## Related Resources
-
-<CardGroup cols={2}>
-  <Card title="Human Feedback in Flows" icon="code" href="/en/learn/human-feedback-in-flows">
-    Implementation guide for the `@human_feedback` decorator
-  </Card>
-  <Card title="Flow HITL Workflow Guide" icon="route" href="/en/enterprise/guides/human-in-the-loop">
-    Step-by-step guide for setting up HITL workflows
-  </Card>
-  <Card title="RBAC Configuration" icon="shield-check" href="/en/enterprise/features/rbac">
-    Configure role-based access control for your organization
-  </Card>
-  <Card title="Webhook Streaming" icon="bolt" href="/en/enterprise/features/webhook-streaming">
-    Set up real-time event notifications
-  </Card>
-</CardGroup>

docs/en/enterprise/guides/human-in-the-loop.mdx

@@ -5,54 +5,9 @@ icon: "user-check"
 mode: "wide"
 ---
 
-Human-In-The-Loop (HITL) is a powerful approach that combines artificial intelligence with human expertise to enhance decision-making and improve task outcomes. This guide shows you how to implement HITL within CrewAI Enterprise.
+Human-In-The-Loop (HITL) is a powerful approach that combines artificial intelligence with human expertise to enhance decision-making and improve task outcomes. This guide shows you how to implement HITL within CrewAI.
 
-## HITL Approaches in CrewAI
-
-CrewAI offers two approaches for implementing human-in-the-loop workflows:
-
-| Approach | Best For | Version |
-|----------|----------|---------|
-| **Flow-based** (`@human_feedback` decorator) | Production with Enterprise UI, email-first workflows, full platform features | **1.8.0+** |
-| **Webhook-based** | Custom integrations, external systems (Slack, Teams, etc.), legacy setups | All versions |
-
-## Flow-Based HITL with Enterprise Platform
-
-<Note>
-The `@human_feedback` decorator requires **CrewAI version 1.8.0 or higher**.
-</Note>
-
-When using the `@human_feedback` decorator in your Flows, CrewAI Enterprise provides an **email-first HITL system** that enables anyone with an email address to respond to review requests:
-
-<CardGroup cols={2}>
-  <Card title="Email-First Design" icon="envelope">
-    Responders receive email notifications and can reply directly—no login required.
-  </Card>
-  <Card title="Dashboard Review" icon="desktop">
-    Review and respond to HITL requests in the Enterprise dashboard when preferred.
-  </Card>
-  <Card title="Flexible Routing" icon="route">
-    Route requests to specific emails based on method patterns or pull from flow state.
-  </Card>
-  <Card title="Auto-Response" icon="clock">
-    Configure automatic fallback responses when no human replies within the timeout.
-  </Card>
-</CardGroup>
-
-### Key Benefits
-
-- **External responders**: Anyone with an email can respond, even non-platform users
-- **Dynamic assignment**: Pull assignee email from flow state (e.g., `account_owner_email`)
-- **Simple configuration**: Email-based routing is easier to set up than user/role management
-- **Deployment creator fallback**: If no routing rule matches, the deployment creator is notified
-
-<Tip>
-For implementation details on the `@human_feedback` decorator, see the [Human Feedback in Flows](/en/learn/human-feedback-in-flows) guide.
-</Tip>
-
-## Setting Up Webhook-Based HITL Workflows
-
-For custom integrations with external systems like Slack, Microsoft Teams, or your own applications, you can use the webhook-based approach:
+## Setting Up HITL Workflows
 
 <Steps>
     <Step title="Configure Your Task">
@@ -144,14 +99,3 @@ HITL workflows are particularly valuable for:
 - Sensitive or high-stakes operations
 - Creative tasks requiring human judgment
 - Compliance and regulatory reviews
-
-## Learn More
-
-<CardGroup cols={2}>
-  <Card title="Flow HITL Management" icon="users-gear" href="/en/enterprise/features/flow-hitl-management">
-    Explore the full Enterprise Flow HITL platform capabilities including email notifications, routing rules, auto-response, and analytics.
-  </Card>
-  <Card title="Human Feedback in Flows" icon="code" href="/en/learn/human-feedback-in-flows">
-    Implementation guide for the `@human_feedback` decorator in your Flows.
-  </Card>
-</CardGroup>

docs/en/learn/human-in-the-loop.mdx

@@ -151,9 +151,3 @@ HITL workflows are particularly valuable for:
 - Sensitive or high-stakes operations
 - Creative tasks requiring human judgment
 - Compliance and regulatory reviews
-
-## Enterprise Features
-
-<Card title="Flow HITL Management Platform" icon="users-gear" href="/en/enterprise/features/flow-hitl-management">
-  CrewAI Enterprise provides a comprehensive HITL management system for Flows with in-platform review, responder assignment, permissions, escalation policies, SLA management, dynamic routing, and full analytics. [Learn more →](/en/enterprise/features/flow-hitl-management)
-</Card>

docs/ko/changelog.mdx

@@ -4,74 +4,6 @@ description: "CrewAI의 제품 업데이트, 개선 사항 및 버그 수정"
 icon: "clock"
 mode: "wide"
 ---
-<Update label="2026년 1월 26일">
-  ## v1.9.0
-
-  [GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/1.9.0)
-
-  ## 변경 사항
-
-  ### 기능
-  - 프로바이더 전반에 걸친 구조화된 출력 및 response_format 지원 추가
-  - 스트리밍 응답에 응답 ID 추가
-  - 부모-자식 계층 구조를 가진 이벤트 순서 추가
-  - Keycloak SSO 인증 지원 추가
-  - 멀티모달 파일 처리 기능 추가
-  - 네이티브 OpenAI responses API 지원 추가
-  - A2A 작업 실행 유틸리티 추가
-  - A2A 서버 구성 및 에이전트 카드 생성 추가
-  - 이벤트 시스템 향상 및 전송 옵션 확장
-  - 도구 호출 메커니즘 개선
-
-  ### 버그 수정
-  - aiocache를 사용할 수 없을 때 폴백 메모리 캐시로 파일 저장소 향상
-  - 문서 목록이 비어 있지 않도록 보장
-  - Bedrock 중지 시퀀스 적절히 처리
-  - Google Vertex API 키 지원 추가
-  - Azure 모델 중지 단어 감지 향상
-  - 흐름 실행 시 HumanFeedbackPending 오류 처리 개선
-  - 실행 스팬 작업 연결 해제 수정
-
-  ### 문서
-  - 네이티브 파일 처리 문서 추가
-  - OpenAI responses API 문서 추가
-  - 에이전트 카드 구현 가이드 추가
-  - A2A 문서 개선
-  - v1.8.0 변경 로그 업데이트
-
-  ### 기여자
-  @Anaisdg, @GininDenis, @Vidit-Ostwal, @greysonlalonde, @heitorado, @joaomdmoura, @koushiv777, @lorenzejay, @nicoferdi96, @vinibrsl
-
-</Update>
-
-<Update label="2026년 1월 15일">
-  ## v1.8.1
-
-  [GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/1.8.1)
-
-  ## 변경 사항
-
-  ### 기능
-  - A2A 작업 실행 유틸리티 추가
-  - A2A 서버 구성 및 에이전트 카드 생성 추가
-  - 추가 전송 메커니즘 추가
-  - Galileo 통합 지원 추가
-
-  ### 버그 수정
-  - Azure 모델 호환성 개선
-  - parent_flow 감지를 위한 프레임 검사 깊이 확장
-  - 작업 실행 스팬 관리 문제 해결
-  - 흐름 실행 중 휴먼 피드백 시나리오에 대한 오류 처리 향상
-
-  ### 문서
-  - A2A 에이전트 카드 문서 추가
-  - PII 삭제 기능 문서 추가
-
-  ### 기여자
-  @Anaisdg, @GininDenis, @greysonlalonde, @joaomdmoura, @koushiv777, @lorenzejay, @vinibrsl
-
-</Update>
-
 <Update label="2026년 1월 8일">
   ## v1.8.0
 

docs/ko/enterprise/features/flow-hitl-management.mdx

@@ -1,563 +0,0 @@
----
-title: "Flow HITL 관리"
-description: "이메일 우선 알림, 라우팅 규칙 및 자동 응답 기능을 갖춘 Flow용 엔터프라이즈급 인간 검토"
-icon: "users-gear"
-mode: "wide"
----
-
-<Note>
-Flow HITL 관리 기능은 `@human_feedback` 데코레이터가 필요하며, **CrewAI 버전 1.8.0 이상**에서 사용할 수 있습니다. 이 기능은 Crew가 아닌 **Flow**에만 적용됩니다.
-</Note>
-
-CrewAI Enterprise는 AI 워크플로우를 협업적인 인간-AI 프로세스로 전환하는 Flow용 포괄적인 Human-in-the-Loop(HITL) 관리 시스템을 제공합니다. 플랫폼은 **이메일 우선 아키텍처**를 사용하여 이메일 주소가 있는 누구나 플랫폼 계정 없이도 검토 요청에 응답할 수 있습니다.
-
-## 개요
-
-<CardGroup cols={3}>
-  <Card title="이메일 우선 설계" icon="envelope">
-    응답자가 알림 이메일에 직접 회신하여 피드백 제공 가능
-  </Card>
-  <Card title="유연한 라우팅" icon="route">
-    메서드 패턴 또는 Flow 상태에 따라 특정 이메일로 요청 라우팅
-  </Card>
-  <Card title="자동 응답" icon="clock">
-    시간 내에 인간이 응답하지 않을 경우 자동 대체 응답 구성
-  </Card>
-</CardGroup>
-
-### 주요 이점
-
-- **간단한 멘탈 모델**: 이메일 주소는 보편적이며 플랫폼 사용자나 역할을 관리할 필요 없음
-- **외부 응답자**: 플랫폼 사용자가 아니어도 이메일이 있는 누구나 응답 가능
-- **동적 할당**: Flow 상태에서 직접 담당자 이메일 가져오기 (예: `sales_rep_email`)
-- **간소화된 구성**: 설정할 항목이 적어 더 빠르게 가치 실현
-- **이메일이 주요 채널**: 대부분의 사용자는 대시보드 로그인보다 이메일로 응답하는 것을 선호
-
-## Flow에서 인간 검토 포인트 설정
-
-`@human_feedback` 데코레이터를 사용하여 Flow 내에 인간 검토 체크포인트를 구성합니다. 실행이 검토 포인트에 도달하면 시스템이 일시 중지되고, 담당자에게 이메일로 알리며, 응답을 기다립니다.
-
-```python
-from crewai.flow.flow import Flow, start, listen
-from crewai.flow.human_feedback import human_feedback, HumanFeedbackResult
-
-class ContentApprovalFlow(Flow):
-    @start()
-    def generate_content(self):
-        # AI가 콘텐츠 생성
-        return "Q1 캠페인용 마케팅 카피 생성..."
-
-    @listen(generate_content)
-    @human_feedback(
-        message="브랜드 준수를 위해 이 콘텐츠를 검토해 주세요:",
-        emit=["approved", "rejected", "needs_revision"],
-    )
-    def review_content(self, content):
-        return content
-
-    @listen("approved")
-    def publish_content(self, result: HumanFeedbackResult):
-        print(f"승인된 콘텐츠 게시 중. 검토자 노트: {result.feedback}")
-
-    @listen("rejected")
-    def archive_content(self, result: HumanFeedbackResult):
-        print(f"콘텐츠 거부됨. 사유: {result.feedback}")
-
-    @listen("needs_revision")
-    def revise_content(self, result: HumanFeedbackResult):
-        print(f"수정 요청: {result.feedback}")
-```
-
-완전한 구현 세부 사항은 [Flow에서 인간 피드백](/ko/learn/human-feedback-in-flows) 가이드를 참조하세요.
-
-### 데코레이터 파라미터
-
-| 파라미터 | 유형 | 설명 |
-|---------|------|------|
-| `message` | `str` | 인간 검토자에게 표시되는 메시지 |
-| `emit` | `list[str]` | 유효한 응답 옵션 (UI에서 버튼으로 표시) |
-
-## 플랫폼 구성
-
-HITL 구성에 접근: **배포** → **설정** → **Human in the Loop 구성**
-
-<Frame>
-  <img src="/images/enterprise/hitl-settings-overview.png" alt="HITL 구성 설정" />
-</Frame>
-
-### 이메일 알림
-
-HITL 요청에 대한 이메일 알림을 활성화하거나 비활성화하는 토글입니다.
-
-| 설정 | 기본값 | 설명 |
-|-----|-------|------|
-| 이메일 알림 | 활성화됨 | 피드백 요청 시 이메일 전송 |
-
-<Note>
-비활성화되면 응답자는 대시보드 UI를 사용하거나 커스텀 알림 시스템을 위해 webhook을 구성해야 합니다.
-</Note>
-
-### SLA 목표
-
-추적 및 메트릭 목적으로 목표 응답 시간을 설정합니다.
-
-| 설정 | 설명 |
-|-----|------|
-| SLA 목표 (분) | 목표 응답 시간. 대시보드 메트릭 및 SLA 추적에 사용 |
-
-SLA 추적을 비활성화하려면 비워 두세요.
-
-## 이메일 알림 및 응답
-
-HITL 시스템은 응답자가 알림 이메일에 직접 회신할 수 있는 이메일 우선 아키텍처를 사용합니다.
-
-### 이메일 응답 작동 방식
-
-<Steps>
-  <Step title="알림 전송">
-    HITL 요청이 생성되면 검토 콘텐츠와 컨텍스트가 포함된 이메일이 할당된 응답자에게 전송됩니다.
-  </Step>
-  <Step title="Reply-To 주소">
-    이메일에는 인증을 위한 서명된 토큰이 포함된 특별한 reply-to 주소가 있습니다.
-  </Step>
-  <Step title="사용자 회신">
-    응답자는 이메일에 피드백으로 회신하면 됩니다—로그인 필요 없음.
-  </Step>
-  <Step title="토큰 검증">
-    플랫폼이 회신을 받고, 서명된 토큰을 확인하고, 발신자 이메일을 매칭합니다.
-  </Step>
-  <Step title="Flow 재개">
-    피드백이 기록되고 인간의 입력으로 Flow가 계속됩니다.
-  </Step>
-</Steps>
-
-### 응답 형식
-
-응답자는 다음과 같이 회신할 수 있습니다:
-
-- **Emit 옵션**: 회신이 `emit` 옵션과 일치하면 (예: "approved") 직접 사용됨
-- **자유 형식 텍스트**: 모든 텍스트 응답이 피드백으로 Flow에 전달됨
-- **일반 텍스트**: 회신 본문의 첫 번째 줄이 피드백으로 사용됨
-
-### 확인 이메일
-
-회신을 처리한 후 응답자는 피드백이 성공적으로 제출되었는지 또는 오류가 발생했는지 나타내는 확인 이메일을 받습니다.
-
-### 이메일 토큰 보안
-
-- 토큰은 보안을 위해 암호화 서명됨
-- 토큰은 7일 후 만료됨
-- 발신자 이메일은 토큰의 인증된 이메일과 일치해야 함
-- 처리 후 확인/오류 이메일 전송됨
-
-## 라우팅 규칙
-
-메서드 패턴에 따라 HITL 요청을 특정 이메일 주소로 라우팅합니다.
-
-<Frame>
-  <img src="/images/enterprise/hitl-settings-routing-rules.png" alt="HITL 라우팅 규칙 구성" />
-</Frame>
-
-### 규칙 구조
-
-```json
-{
-  "name": "재무팀으로 승인",
-  "match": {
-    "method_name": "approve_*"
-  },
-  "assign_to_email": "finance@company.com",
-  "assign_from_input": "manager_email"
-}
-```
-
-### 매칭 패턴
-
-| 패턴 | 설명 | 매칭 예시 |
-|-----|------|----------|
-| `approve_*` | 와일드카드 (모든 문자) | `approve_payment`, `approve_vendor` |
-| `review_?` | 단일 문자 | `review_a`, `review_1` |
-| `validate_payment` | 정확히 일치 | `validate_payment`만 |
-
-### 할당 우선순위
-
-1. **동적 할당** (`assign_from_input`): 구성된 경우 Flow 상태에서 이메일 가져옴
-2. **정적 이메일** (`assign_to_email`): 구성된 이메일로 대체
-3. **배포 생성자**: 규칙이 일치하지 않으면 배포 생성자의 이메일이 사용됨
-
-### 동적 할당 예제
-
-Flow 상태에 `{"sales_rep_email": "alice@company.com"}`이 포함된 경우:
-
-```json
-{
-  "name": "영업 담당자에게 라우팅",
-  "match": {
-    "method_name": "review_*"
-  },
-  "assign_from_input": "sales_rep_email"
-}
-```
-
-요청이 자동으로 `alice@company.com`에 할당됩니다.
-
-<Tip>
-**사용 사례**: CRM, 데이터베이스 또는 이전 Flow 단계에서 담당자를 가져와 적합한 사람에게 검토를 동적으로 라우팅하세요.
-</Tip>
-
-## 자동 응답
-
-시간 내에 인간이 응답하지 않으면 HITL 요청에 자동으로 응답합니다. 이를 통해 Flow가 무한정 중단되지 않도록 합니다.
-
-### 구성
-
-| 설정 | 설명 |
-|-----|------|
-| 활성화됨 | 자동 응답 활성화 토글 |
-| 타임아웃 (분) | 자동 응답 전 대기 시간 |
-| 기본 결과 | 응답 값 (`emit` 옵션과 일치해야 함) |
-
-<Frame>
-  <img src="/images/enterprise/hitl-settings-auto-respond.png" alt="HITL 자동 응답 구성" />
-</Frame>
-
-### 사용 사례
-
-- **SLA 준수**: Flow가 무한정 중단되지 않도록 보장
-- **기본 승인**: 타임아웃 후 저위험 요청 자동 승인
-- **우아한 저하**: 검토자가 없을 때 안전한 기본값으로 계속
-
-<Warning>
-자동 응답을 신중하게 사용하세요. 기본 응답이 허용되는 중요하지 않은 검토에만 활성화하세요.
-</Warning>
-
-## 검토 프로세스
-
-### 대시보드 인터페이스
-
-HITL 검토 인터페이스는 검토자에게 깔끔하고 집중된 경험을 제공합니다:
-
-- **마크다운 렌더링**: 구문 강조가 포함된 풍부한 형식의 검토 콘텐츠
-- **컨텍스트 패널**: Flow 상태, 실행 기록 및 관련 정보 보기
-- **피드백 입력**: 결정과 함께 상세한 피드백 및 코멘트 제공
-- **빠른 작업**: 선택적 코멘트가 있는 원클릭 emit 옵션 버튼
-
-<Frame>
-  <img src="/images/enterprise/hitl-list-pending-feedbacks.png" alt="HITL 대기 중인 요청 목록" />
-</Frame>
-
-### 응답 방법
-
-검토자는 세 가지 채널을 통해 응답할 수 있습니다:
-
-| 방법 | 설명 |
-|-----|------|
-| **이메일 회신** | 알림 이메일에 직접 회신 |
-| **대시보드** | Enterprise 대시보드 UI 사용 |
-| **API/Webhook** | API를 통한 프로그래밍 방식 응답 |
-
-### 기록 및 감사 추적
-
-모든 HITL 상호작용은 완전한 타임라인으로 추적됩니다:
-
-- 결정 기록 (승인/거부/수정)
-- 검토자 신원 및 타임스탬프
-- 제공된 피드백 및 코멘트
-- 응답 방법 (이메일/대시보드/API)
-- 응답 시간 메트릭
-
-## 분석 및 모니터링
-
-포괄적인 분석으로 HITL 성능을 추적합니다.
-
-### 성능 대시보드
-
-<Frame>
-  <img src="/images/enterprise/hitl-metrics.png" alt="HITL 메트릭 대시보드" />
-</Frame>
-
-<CardGroup cols={2}>
-  <Card title="응답 시간" icon="stopwatch">
-    검토자 또는 Flow별 평균 및 중앙값 응답 시간 모니터링.
-  </Card>
-  <Card title="볼륨 트렌드" icon="chart-bar">
-    팀 용량 최적화를 위한 검토 볼륨 패턴 분석.
-  </Card>
-  <Card title="결정 분포" icon="chart-pie">
-    다양한 검토 유형에 대한 승인/거부 비율 보기.
-  </Card>
-  <Card title="SLA 추적" icon="chart-line">
-    SLA 목표 내에 완료된 검토 비율 추적.
-  </Card>
-</CardGroup>
-
-### 감사 및 규정 준수
-
-규제 요구 사항을 위한 엔터프라이즈급 감사 기능:
-
-- 타임스탬프가 있는 완전한 결정 기록
-- 검토자 신원 확인
-- 불변 감사 로그
-- 규정 준수 보고를 위한 내보내기 기능
-
-## 일반적인 사용 사례
-
-<AccordionGroup>
-  <Accordion title="보안 검토" icon="shield-halved">
-    **사용 사례**: 인간 검증이 포함된 내부 보안 설문지 자동화
-
-    - AI가 보안 설문지에 대한 응답 생성
-    - 보안팀이 이메일로 정확성 검토 및 검증
-    - 승인된 응답이 최종 제출물로 편집
-    - 규정 준수를 위한 완전한 감사 추적
-  </Accordion>
-
-  <Accordion title="콘텐츠 승인" icon="file-lines">
-    **사용 사례**: 법무/브랜드 검토가 필요한 마케팅 콘텐츠
-
-    - AI가 마케팅 카피 또는 소셜 미디어 콘텐츠 생성
-    - 브랜드팀 이메일로 목소리/톤 검토를 위해 라우팅
-    - 승인 시 자동 게시
-  </Accordion>
-
-  <Accordion title="재무 승인" icon="money-bill">
-    **사용 사례**: 경비 보고서, 계약 조건, 예산 배분
-
-    - AI가 재무 요청을 사전 처리하고 분류
-    - 동적 할당을 사용하여 금액 임계값에 따라 라우팅
-    - 재무 규정 준수를 위한 완전한 감사 추적 유지
-  </Accordion>
-
-  <Accordion title="CRM에서 동적 할당" icon="database">
-    **사용 사례**: CRM에서 계정 담당자에게 검토 라우팅
-
-    - Flow가 CRM에서 계정 담당자 이메일 가져옴
-    - 이메일을 Flow 상태에 저장 (예: `account_owner_email`)
-    - `assign_from_input`을 사용하여 적합한 사람에게 자동 라우팅
-  </Accordion>
-
-  <Accordion title="품질 보증" icon="magnifying-glass">
-    **사용 사례**: 고객 전달 전 AI 출력 검증
-
-    - AI가 고객 대면 콘텐츠 또는 응답 생성
-    - QA팀이 이메일 알림을 통해 검토
-    - 피드백 루프가 시간이 지남에 따라 AI 성능 개선
-  </Accordion>
-</AccordionGroup>
-
-## Webhook API
-
-Flow가 인간 피드백을 위해 일시 중지되면, 요청 데이터를 자체 애플리케이션으로 보내도록 webhook을 구성할 수 있습니다. 이를 통해 다음이 가능합니다:
-
-- 커스텀 승인 UI 구축
-- 내부 도구와 통합 (Jira, ServiceNow, 커스텀 대시보드)
-- 타사 시스템으로 승인 라우팅
-- 모바일 앱 알림
-- 자동화된 결정 시스템
-
-<Frame>
-  <img src="/images/enterprise/hitl-settings-webhook.png" alt="HITL Webhook 구성" />
-</Frame>
-
-### Webhook 구성
-
-<Steps>
-  <Step title="설정으로 이동">
-    **배포** → **설정** → **Human in the Loop**으로 이동
-  </Step>
-  <Step title="Webhook 섹션 확장">
-    **Webhooks** 구성을 클릭하여 확장
-  </Step>
-  <Step title="Webhook URL 추가">
-    webhook URL 입력 (프로덕션에서는 HTTPS 필수)
-  </Step>
-  <Step title="구성 저장">
-    **구성 저장**을 클릭하여 활성화
-  </Step>
-</Steps>
-
-여러 webhook을 구성할 수 있습니다. 각 활성 webhook은 모든 HITL 이벤트를 수신합니다.
-
-### Webhook 이벤트
-
-엔드포인트는 다음 이벤트에 대해 HTTP POST 요청을 수신합니다:
-
-| 이벤트 유형 | 트리거 시점 |
-|------------|------------|
-| `new_request` | Flow가 일시 중지되고 인간 피드백을 요청할 때 |
-
-### Webhook 페이로드
-
-모든 webhook은 다음 구조의 JSON 페이로드를 수신합니다:
-
-```json
-{
-  "event": "new_request",
-  "request": {
-    "id": "550e8400-e29b-41d4-a716-446655440000",
-    "flow_id": "flow_abc123",
-    "method_name": "review_article",
-    "message": "이 기사의 게시를 검토해 주세요.",
-    "emit_options": ["approved", "rejected", "request_changes"],
-    "state": {
-      "article_id": 12345,
-      "author": "john@example.com",
-      "category": "technology"
-    },
-    "metadata": {},
-    "created_at": "2026-01-14T12:00:00Z"
-  },
-  "deployment": {
-    "id": 456,
-    "name": "Content Review Flow",
-    "organization_id": 789
-  },
-  "callback_url": "https://api.crewai.com/...",
-  "assigned_to_email": "reviewer@company.com"
-}
-```
-
-### 요청에 응답하기
-
-피드백을 제출하려면 webhook 페이로드에 포함된 **`callback_url`로 POST**합니다.
-
-```http
-POST {callback_url}
-Content-Type: application/json
-
-{
-  "feedback": "승인됨. 훌륭한 기사입니다!",
-  "source": "my_custom_app"
-}
-```
-
-### 보안
-
-<Info>
-모든 webhook 요청은 HMAC-SHA256을 사용하여 암호화 서명되어 진위성을 보장하고 변조를 방지합니다.
-</Info>
-
-#### Webhook 보안
-
-- **HMAC-SHA256 서명**: 모든 webhook에 암호화 서명이 포함됨
-- **Webhook별 시크릿**: 각 webhook은 고유한 서명 시크릿을 가짐
-- **저장 시 암호화**: 서명 시크릿은 데이터베이스에서 암호화됨
-- **타임스탬프 검증**: 리플레이 공격 방지
-
-#### 서명 헤더
-
-각 webhook 요청에는 다음 헤더가 포함됩니다:
-
-| 헤더 | 설명 |
-|------|------|
-| `X-Signature` | HMAC-SHA256 서명: `sha256=<hex_digest>` |
-| `X-Timestamp` | 요청이 서명된 Unix 타임스탬프 |
-
-#### 검증
-
-다음과 같이 계산하여 검증합니다:
-
-```python
-import hmac
-import hashlib
-
-expected = hmac.new(
-    signing_secret.encode(),
-    f"{timestamp}.{payload}".encode(),
-    hashlib.sha256
-).hexdigest()
-
-if hmac.compare_digest(expected, signature):
-    # 유효한 서명
-```
-
-### 오류 처리
-
-webhook 엔드포인트는 수신 확인을 위해 2xx 상태 코드를 반환해야 합니다:
-
-| 응답 | 동작 |
-|------|------|
-| 2xx | Webhook 성공적으로 전달됨 |
-| 4xx/5xx | 실패로 기록됨, 재시도 없음 |
-| 타임아웃 (30초) | 실패로 기록됨, 재시도 없음 |
-
-## 보안 및 RBAC
-
-### 대시보드 접근
-
-HITL 접근은 배포 수준에서 제어됩니다:
-
-| 권한 | 기능 |
-|-----|------|
-| `manage_human_feedback` | HITL 설정 구성, 모든 요청 보기 |
-| `respond_to_human_feedback` | 요청에 응답, 할당된 요청 보기 |
-
-### 이메일 응답 인증
-
-이메일 회신의 경우:
-1. reply-to 토큰이 인증된 이메일을 인코딩
-2. 발신자 이메일이 토큰의 이메일과 일치해야 함
-3. 토큰이 만료되지 않아야 함 (기본 7일)
-4. 요청이 여전히 대기 중이어야 함
-
-### 감사 추적
-
-모든 HITL 작업이 기록됩니다:
-- 요청 생성
-- 할당 변경
-- 응답 제출 (소스: 대시보드/이메일/API)
-- Flow 재개 상태
-
-## 문제 해결
-
-### 이메일이 전송되지 않음
-
-1. 구성에서 "이메일 알림"이 활성화되어 있는지 확인
-2. 라우팅 규칙이 메서드 이름과 일치하는지 확인
-3. 담당자 이메일이 유효한지 확인
-4. 라우팅 규칙이 일치하지 않는 경우 배포 생성자 대체 확인
-
-### 이메일 회신이 처리되지 않음
-
-1. 토큰이 만료되지 않았는지 확인 (기본 7일)
-2. 발신자 이메일이 할당된 이메일과 일치하는지 확인
-3. 요청이 여전히 대기 중인지 확인 (아직 응답되지 않음)
-
-### Flow가 재개되지 않음
-
-1. 대시보드에서 요청 상태 확인
-2. 콜백 URL에 접근 가능한지 확인
-3. 배포가 여전히 실행 중인지 확인
-
-## 모범 사례
-
-<Tip>
-**간단하게 시작**: 배포 생성자에게 이메일 알림으로 시작한 다음, 워크플로우가 성숙해지면 라우팅 규칙을 추가하세요.
-</Tip>
-
-1. **동적 할당 사용**: 유연한 라우팅을 위해 Flow 상태에서 담당자 이메일을 가져오세요.
-
-2. **자동 응답 구성**: 중요하지 않은 검토에 대해 Flow가 중단되지 않도록 대체를 설정하세요.
-
-3. **응답 시간 모니터링**: 분석을 사용하여 병목 현상을 식별하고 검토 프로세스를 최적화하세요.
-
-4. **검토 메시지를 명확하게 유지**: `@human_feedback` 데코레이터에 명확하고 실행 가능한 메시지를 작성하세요.
-
-5. **이메일 흐름 테스트**: 프로덕션에 가기 전에 테스트 요청을 보내 이메일 전달을 확인하세요.
-
-## 관련 리소스
-
-<CardGroup cols={2}>
-  <Card title="Flow에서 인간 피드백" icon="code" href="/ko/learn/human-feedback-in-flows">
-    `@human_feedback` 데코레이터 구현 가이드
-  </Card>
-  <Card title="Flow HITL 워크플로우 가이드" icon="route" href="/ko/enterprise/guides/human-in-the-loop">
-    HITL 워크플로우 설정을 위한 단계별 가이드
-  </Card>
-  <Card title="RBAC 구성" icon="shield-check" href="/ko/enterprise/features/rbac">
-    조직을 위한 역할 기반 접근 제어 구성
-  </Card>
-  <Card title="Webhook 스트리밍" icon="bolt" href="/ko/enterprise/features/webhook-streaming">
-    실시간 이벤트 알림 설정
-  </Card>
-</CardGroup>

docs/ko/enterprise/guides/human-in-the-loop.mdx

@@ -5,54 +5,9 @@ icon: "user-check"
 mode: "wide"
 ---
 
-인간-중심(Human-In-The-Loop, HITL)은 인공지능과 인간 전문 지식을 결합하여 의사결정을 강화하고 작업 결과를 향상시키는 강력한 접근 방식입니다. 이 가이드는 CrewAI Enterprise 내에서 HITL을 구현하는 방법을 보여줍니다.
+인간-중심(Human-In-The-Loop, HITL)은 인공지능과 인간 전문 지식을 결합하여 의사결정을 강화하고 작업 결과를 향상시키는 강력한 접근 방식입니다. 이 가이드는 CrewAI 내에서 HITL을 구현하는 방법을 보여줍니다.
 
-## CrewAI의 HITL 접근 방식
-
-CrewAI는 human-in-the-loop 워크플로우를 구현하기 위한 두 가지 접근 방식을 제공합니다:
-
-| 접근 방식 | 적합한 용도 | 버전 |
-|----------|----------|---------|
-| **Flow 기반** (`@human_feedback` 데코레이터) | Enterprise UI를 사용한 프로덕션, 이메일 우선 워크플로우, 전체 플랫폼 기능 | **1.8.0+** |
-| **Webhook 기반** | 커스텀 통합, 외부 시스템 (Slack, Teams 등), 레거시 설정 | 모든 버전 |
-
-## Enterprise 플랫폼과 Flow 기반 HITL
-
-<Note>
-`@human_feedback` 데코레이터는 **CrewAI 버전 1.8.0 이상**이 필요합니다.
-</Note>
-
-Flow에서 `@human_feedback` 데코레이터를 사용하면, CrewAI Enterprise는 이메일 주소가 있는 누구나 검토 요청에 응답할 수 있는 **이메일 우선 HITL 시스템**을 제공합니다:
-
-<CardGroup cols={2}>
-  <Card title="이메일 우선 설계" icon="envelope">
-    응답자가 이메일 알림을 받고 직접 회신할 수 있습니다—로그인이 필요 없습니다.
-  </Card>
-  <Card title="대시보드 검토" icon="desktop">
-    원할 때 Enterprise 대시보드에서 HITL 요청을 검토하고 응답하세요.
-  </Card>
-  <Card title="유연한 라우팅" icon="route">
-    메서드 패턴에 따라 특정 이메일로 요청을 라우팅하거나 Flow 상태에서 가져오세요.
-  </Card>
-  <Card title="자동 응답" icon="clock">
-    타임아웃 내에 인간이 응답하지 않을 경우 자동 대체 응답을 구성하세요.
-  </Card>
-</CardGroup>
-
-### 주요 이점
-
-- **외부 응답자**: 플랫폼 사용자가 아니어도 이메일이 있는 누구나 응답 가능
-- **동적 할당**: Flow 상태에서 담당자 이메일 가져오기 (예: `account_owner_email`)
-- **간단한 구성**: 이메일 기반 라우팅은 사용자/역할 관리보다 설정이 쉬움
-- **배포 생성자 대체**: 라우팅 규칙이 일치하지 않으면 배포 생성자에게 알림
-
-<Tip>
-`@human_feedback` 데코레이터의 구현 세부 사항은 [Flow에서 인간 피드백](/ko/learn/human-feedback-in-flows) 가이드를 참조하세요.
-</Tip>
-
-## Webhook 기반 HITL 워크플로 설정
-
-Slack, Microsoft Teams 또는 자체 애플리케이션과 같은 외부 시스템과의 커스텀 통합을 위해 webhook 기반 접근 방식을 사용할 수 있습니다:
+## HITL 워크플로 설정
 
 <Steps>
     <Step title="작업 구성">
@@ -144,14 +99,3 @@ HITL 워크플로우는 특히 다음과 같은 경우에 유용합니다:
 - 민감하거나 위험도가 높은 작업
 - 인간의 판단이 필요한 창의적 작업
 - 준수 및 규제 검토
-
-## 자세히 알아보기
-
-<CardGroup cols={2}>
-  <Card title="Flow HITL 관리" icon="users-gear" href="/ko/enterprise/features/flow-hitl-management">
-    이메일 알림, 라우팅 규칙, 자동 응답 및 분석을 포함한 전체 Enterprise Flow HITL 플랫폼 기능을 살펴보세요.
-  </Card>
-  <Card title="Flow에서 인간 피드백" icon="code" href="/ko/learn/human-feedback-in-flows">
-    Flow에서 `@human_feedback` 데코레이터 구현 가이드.
-  </Card>
-</CardGroup>

docs/ko/learn/human-in-the-loop.mdx

@@ -112,9 +112,3 @@ HITL 워크플로우는 다음과 같은 경우에 특히 유용합니다:
 - 민감하거나 고위험 작업
 - 인간의 판단이 필요한 창의적 과제
 - 컴플라이언스 및 규제 검토
-
-## Enterprise 기능
-
-<Card title="Flow HITL 관리 플랫폼" icon="users-gear" href="/ko/enterprise/features/flow-hitl-management">
-  CrewAI Enterprise는 플랫폼 내 검토, 응답자 할당, 권한, 에스컬레이션 정책, SLA 관리, 동적 라우팅 및 전체 분석을 갖춘 Flow용 포괄적인 HITL 관리 시스템을 제공합니다. [자세히 알아보기 →](/ko/enterprise/features/flow-hitl-management)
-</Card>

docs/pt-BR/changelog.mdx

@@ -4,74 +4,6 @@ description: "Atualizações de produto, melhorias e correções do CrewAI"
 icon: "clock"
 mode: "wide"
 ---
-<Update label="26 jan 2026">
-  ## v1.9.0
-
-  [Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.9.0)
-
-  ## O que Mudou
-
-  ### Funcionalidades
-  - Adicionar suporte a saídas estruturadas e response_format em vários provedores
-  - Adicionar ID de resposta às respostas de streaming
-  - Adicionar ordenação de eventos com hierarquias pai-filho
-  - Adicionar suporte à autenticação SSO Keycloak
-  - Adicionar capacidades de manipulação de arquivos multimodais
-  - Adicionar suporte nativo à API de respostas OpenAI
-  - Adicionar utilitários de execução de tarefas A2A
-  - Adicionar configuração de servidor A2A e geração de cartão de agente
-  - Aprimorar sistema de eventos e expandir opções de transporte
-  - Melhorar mecanismos de chamada de ferramentas
-
-  ### Correções de Bugs
-  - Aprimorar armazenamento de arquivos com cache de memória de fallback quando aiocache não está disponível
-  - Garantir que lista de documentos não esteja vazia
-  - Tratar sequências de parada do Bedrock adequadamente
-  - Adicionar suporte à chave de API do Google Vertex
-  - Aprimorar detecção de palavras de parada do modelo Azure
-  - Melhorar tratamento de erros para HumanFeedbackPending na execução de fluxo
-  - Corrigir desvinculação de tarefa do span de execução
-
-  ### Documentação
-  - Adicionar documentação de manipulação nativa de arquivos
-  - Adicionar documentação da API de respostas OpenAI
-  - Adicionar orientação de implementação de cartão de agente
-  - Refinar documentação A2A
-  - Atualizar changelog para v1.8.0
-
-  ### Contribuidores
-  @Anaisdg, @GininDenis, @Vidit-Ostwal, @greysonlalonde, @heitorado, @joaomdmoura, @koushiv777, @lorenzejay, @nicoferdi96, @vinibrsl
-
-</Update>
-
-<Update label="15 jan 2026">
-  ## v1.8.1
-
-  [Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.8.1)
-
-  ## O que Mudou
-
-  ### Funcionalidades
-  - Adicionar utilitários de execução de tarefas A2A
-  - Adicionar configuração de servidor A2A e geração de cartão de agente
-  - Adicionar mecanismos de transporte adicionais
-  - Adicionar suporte à integração Galileo
-
-  ### Correções de Bugs
-  - Melhorar compatibilidade do modelo Azure
-  - Expandir profundidade de inspeção de frame para detectar parent_flow
-  - Resolver problemas de gerenciamento de span de execução de tarefas
-  - Aprimorar tratamento de erros para cenários de feedback humano durante execução de fluxo
-
-  ### Documentação
-  - Adicionar documentação de cartão de agente A2A
-  - Adicionar documentação de recurso de redação de PII
-
-  ### Contribuidores
-  @Anaisdg, @GininDenis, @greysonlalonde, @joaomdmoura, @koushiv777, @lorenzejay, @vinibrsl
-
-</Update>
-
 <Update label="08 jan 2026">
   ## v1.8.0
 

docs/pt-BR/enterprise/features/flow-hitl-management.mdx

@@ -1,563 +0,0 @@
----
-title: "Gerenciamento HITL para Flows"
-description: "Revisão humana de nível empresarial para Flows com notificações por email, regras de roteamento e capacidades de resposta automática"
-icon: "users-gear"
-mode: "wide"
----
-
-<Note>
-Os recursos de gerenciamento HITL para Flows requerem o decorador `@human_feedback`, disponível no **CrewAI versão 1.8.0 ou superior**. Estes recursos aplicam-se especificamente a **Flows**, não a Crews.
-</Note>
-
-O CrewAI Enterprise oferece um sistema abrangente de gerenciamento Human-in-the-Loop (HITL) para Flows que transforma fluxos de trabalho de IA em processos colaborativos humano-IA. A plataforma usa uma **arquitetura email-first** que permite que qualquer pessoa com um endereço de email responda a solicitações de revisão—sem necessidade de conta na plataforma.
-
-## Visão Geral
-
-<CardGroup cols={3}>
-  <Card title="Design Email-First" icon="envelope">
-    Respondentes podem responder diretamente aos emails de notificação para fornecer feedback
-  </Card>
-  <Card title="Roteamento Flexível" icon="route">
-    Direcione solicitações para emails específicos com base em padrões de método ou estado do flow
-  </Card>
-  <Card title="Resposta Automática" icon="clock">
-    Configure respostas automáticas de fallback quando nenhum humano responder a tempo
-  </Card>
-</CardGroup>
-
-### Principais Benefícios
-
-- **Modelo mental simples**: Endereços de email são universais; não é necessário gerenciar usuários ou funções da plataforma
-- **Respondentes externos**: Qualquer pessoa com email pode responder, mesmo não sendo usuário da plataforma
-- **Atribuição dinâmica**: Obtenha o email do responsável diretamente do estado do flow (ex: `sales_rep_email`)
-- **Configuração reduzida**: Menos configurações para definir, tempo mais rápido para gerar valor
-- **Email como canal principal**: A maioria dos usuários prefere responder via email do que fazer login em um dashboard
-
-## Configurando Pontos de Revisão Humana em Flows
-
-Configure checkpoints de revisão humana em seus Flows usando o decorador `@human_feedback`. Quando a execução atinge um ponto de revisão, o sistema pausa, notifica o responsável via email e aguarda uma resposta.
-
-```python
-from crewai.flow.flow import Flow, start, listen
-from crewai.flow.human_feedback import human_feedback, HumanFeedbackResult
-
-class ContentApprovalFlow(Flow):
-    @start()
-    def generate_content(self):
-        # IA gera conteúdo
-        return "Texto de marketing gerado para campanha Q1..."
-
-    @listen(generate_content)
-    @human_feedback(
-        message="Por favor, revise este conteúdo para conformidade com a marca:",
-        emit=["approved", "rejected", "needs_revision"],
-    )
-    def review_content(self, content):
-        return content
-
-    @listen("approved")
-    def publish_content(self, result: HumanFeedbackResult):
-        print(f"Publicando conteúdo aprovado. Notas do revisor: {result.feedback}")
-
-    @listen("rejected")
-    def archive_content(self, result: HumanFeedbackResult):
-        print(f"Conteúdo rejeitado. Motivo: {result.feedback}")
-
-    @listen("needs_revision")
-    def revise_content(self, result: HumanFeedbackResult):
-        print(f"Revisão solicitada: {result.feedback}")
-```
-
-Para detalhes completos de implementação, consulte o guia [Feedback Humano em Flows](/pt-BR/learn/human-feedback-in-flows).
-
-### Parâmetros do Decorador
-
-| Parâmetro | Tipo | Descrição |
-|-----------|------|-----------|
-| `message` | `str` | A mensagem exibida para o revisor humano |
-| `emit` | `list[str]` | Opções de resposta válidas (exibidas como botões na UI) |
-
-## Configuração da Plataforma
-
-Acesse a configuração HITL em: **Deployment** → **Settings** → **Human in the Loop Configuration**
-
-<Frame>
-  <img src="/images/enterprise/hitl-settings-overview.png" alt="Configurações HITL" />
-</Frame>
-
-### Notificações por Email
-
-Toggle para ativar ou desativar notificações por email para solicitações HITL.
-
-| Configuração | Padrão | Descrição |
-|--------------|--------|-----------|
-| Notificações por Email | Ativado | Enviar emails quando feedback for solicitado |
-
-<Note>
-Quando desativado, os respondentes devem usar a UI do dashboard ou você deve configurar webhooks para sistemas de notificação personalizados.
-</Note>
-
-### Meta de SLA
-
-Defina um tempo de resposta alvo para fins de rastreamento e métricas.
-
-| Configuração | Descrição |
-|--------------|-----------|
-| Meta de SLA (minutos) | Tempo de resposta alvo. Usado para métricas do dashboard e rastreamento de SLA |
-
-Deixe vazio para desativar o rastreamento de SLA.
-
-## Notificações e Respostas por Email
-
-O sistema HITL usa uma arquitetura email-first onde os respondentes podem responder diretamente aos emails de notificação.
-
-### Como Funcionam as Respostas por Email
-
-<Steps>
-  <Step title="Notificação Enviada">
-    Quando uma solicitação HITL é criada, um email é enviado ao respondente atribuído com o conteúdo e contexto da revisão.
-  </Step>
-  <Step title="Endereço Reply-To">
-    O email inclui um endereço reply-to especial com um token assinado para autenticação.
-  </Step>
-  <Step title="Usuário Responde">
-    O respondente simplesmente responde ao email com seu feedback—nenhum login necessário.
-  </Step>
-  <Step title="Validação do Token">
-    A plataforma recebe a resposta, verifica o token assinado e corresponde o email do remetente.
-  </Step>
-  <Step title="Flow Continua">
-    O feedback é registrado e o flow continua com a entrada humana.
-  </Step>
-</Steps>
-
-### Formato de Resposta
-
-Respondentes podem responder com:
-
-- **Opção emit**: Se a resposta corresponder a uma opção `emit` (ex: "approved"), ela é usada diretamente
-- **Texto livre**: Qualquer resposta de texto é passada para o flow como feedback
-- **Texto simples**: A primeira linha do corpo da resposta é usada como feedback
-
-### Emails de Confirmação
-
-Após processar uma resposta, o respondente recebe um email de confirmação indicando se o feedback foi enviado com sucesso ou se ocorreu um erro.
-
-### Segurança do Token de Email
-
-- Tokens são assinados criptograficamente para segurança
-- Tokens expiram após 7 dias
-- Email do remetente deve corresponder ao email autorizado do token
-- Emails de confirmação/erro são enviados após o processamento
-
-## Regras de Roteamento
-
-Direcione solicitações HITL para endereços de email específicos com base em padrões de método.
-
-<Frame>
-  <img src="/images/enterprise/hitl-settings-routing-rules.png" alt="Configuração de Regras de Roteamento HITL" />
-</Frame>
-
-### Estrutura da Regra
-
-```json
-{
-  "name": "Aprovações para Financeiro",
-  "match": {
-    "method_name": "approve_*"
-  },
-  "assign_to_email": "financeiro@empresa.com",
-  "assign_from_input": "manager_email"
-}
-```
-
-### Padrões de Correspondência
-
-| Padrão | Descrição | Exemplo de Correspondência |
-|--------|-----------|---------------------------|
-| `approve_*` | Wildcard (qualquer caractere) | `approve_payment`, `approve_vendor` |
-| `review_?` | Caractere único | `review_a`, `review_1` |
-| `validate_payment` | Correspondência exata | apenas `validate_payment` |
-
-### Prioridade de Atribuição
-
-1. **Atribuição dinâmica** (`assign_from_input`): Se configurado, obtém email do estado do flow
-2. **Email estático** (`assign_to_email`): Fallback para email configurado
-3. **Criador do deployment**: Se nenhuma regra corresponder, o email do criador do deployment é usado
-
-### Exemplo de Atribuição Dinâmica
-
-Se seu estado do flow contém `{"sales_rep_email": "alice@empresa.com"}`, configure:
-
-```json
-{
-  "name": "Direcionar para Representante de Vendas",
-  "match": {
-    "method_name": "review_*"
-  },
-  "assign_from_input": "sales_rep_email"
-}
-```
-
-A solicitação será atribuída automaticamente para `alice@empresa.com`.
-
-<Tip>
-**Caso de Uso**: Obtenha o responsável do seu CRM, banco de dados ou etapa anterior do flow para direcionar revisões dinamicamente para a pessoa certa.
-</Tip>
-
-## Resposta Automática
-
-Responda automaticamente a solicitações HITL se nenhum humano responder dentro do timeout. Isso garante que os flows não fiquem travados indefinidamente.
-
-### Configuração
-
-| Configuração | Descrição |
-|--------------|-----------|
-| Ativado | Toggle para ativar resposta automática |
-| Timeout (minutos) | Tempo de espera antes de responder automaticamente |
-| Resultado Padrão | O valor da resposta (deve corresponder a uma opção `emit`) |
-
-<Frame>
-  <img src="/images/enterprise/hitl-settings-auto-respond.png" alt="Configuração de Resposta Automática HITL" />
-</Frame>
-
-### Casos de Uso
-
-- **Conformidade com SLA**: Garante que flows não fiquem travados indefinidamente
-- **Aprovação padrão**: Aprove automaticamente solicitações de baixo risco após timeout
-- **Degradação graciosa**: Continue com um padrão seguro quando revisores não estiverem disponíveis
-
-<Warning>
-Use resposta automática com cuidado. Ative apenas para revisões não críticas onde uma resposta padrão é aceitável.
-</Warning>
-
-## Processo de Revisão
-
-### Interface do Dashboard
-
-A interface de revisão HITL oferece uma experiência limpa e focada para revisores:
-
-- **Renderização Markdown**: Formatação rica para conteúdo de revisão com destaque de sintaxe
-- **Painel de Contexto**: Visualize estado do flow, histórico de execução e informações relacionadas
-- **Entrada de Feedback**: Forneça feedback detalhado e comentários com sua decisão
-- **Ações Rápidas**: Botões de opção emit com um clique com comentários opcionais
-
-<Frame>
-  <img src="/images/enterprise/hitl-list-pending-feedbacks.png" alt="Lista de Solicitações HITL Pendentes" />
-</Frame>
-
-### Métodos de Resposta
-
-Revisores podem responder por três canais:
-
-| Método | Descrição |
-|--------|-----------|
-| **Resposta por Email** | Responda diretamente ao email de notificação |
-| **Dashboard** | Use a UI do dashboard Enterprise |
-| **API/Webhook** | Resposta programática via API |
-
-### Histórico e Trilha de Auditoria
-
-Toda interação HITL é rastreada com uma linha do tempo completa:
-
-- Histórico de decisões (aprovar/rejeitar/revisar)
-- Identidade do revisor e timestamp
-- Feedback e comentários fornecidos
-- Método de resposta (email/dashboard/API)
-- Métricas de tempo de resposta
-
-## Análise e Monitoramento
-
-Acompanhe o desempenho HITL com análises abrangentes.
-
-### Dashboard de Desempenho
-
-<Frame>
-  <img src="/images/enterprise/hitl-metrics.png" alt="Dashboard de Métricas HITL" />
-</Frame>
-
-<CardGroup cols={2}>
-  <Card title="Tempos de Resposta" icon="stopwatch">
-    Monitore tempos de resposta médios e medianos por revisor ou flow.
-  </Card>
-  <Card title="Tendências de Volume" icon="chart-bar">
-    Analise padrões de volume de revisão para otimizar capacidade da equipe.
-  </Card>
-  <Card title="Distribuição de Decisões" icon="chart-pie">
-    Visualize taxas de aprovação/rejeição em diferentes tipos de revisão.
-  </Card>
-  <Card title="Rastreamento de SLA" icon="chart-line">
-    Acompanhe a porcentagem de revisões concluídas dentro das metas de SLA.
-  </Card>
-</CardGroup>
-
-### Auditoria e Conformidade
-
-Capacidades de auditoria prontas para empresas para requisitos regulatórios:
-
-- Histórico completo de decisões com timestamps
-- Verificação de identidade do revisor
-- Logs de auditoria imutáveis
-- Capacidades de exportação para relatórios de conformidade
-
-## Casos de Uso Comuns
-
-<AccordionGroup>
-  <Accordion title="Revisões de Segurança" icon="shield-halved">
-    **Caso de Uso**: Automação de questionários de segurança internos com validação humana
-
-    - IA gera respostas para questionários de segurança
-    - Equipe de segurança revisa e valida precisão via email
-    - Respostas aprovadas são compiladas na submissão final
-    - Trilha de auditoria completa para conformidade
-  </Accordion>
-
-  <Accordion title="Aprovação de Conteúdo" icon="file-lines">
-    **Caso de Uso**: Conteúdo de marketing que requer revisão legal/marca
-
-    - IA gera texto de marketing ou conteúdo de mídia social
-    - Roteie para email da equipe de marca para revisão de voz/tom
-    - Publicação automática após aprovação
-  </Accordion>
-
-  <Accordion title="Aprovações Financeiras" icon="money-bill">
-    **Caso de Uso**: Relatórios de despesas, termos de contrato, alocações de orçamento
-
-    - IA pré-processa e categoriza solicitações financeiras
-    - Roteie com base em limites de valor usando atribuição dinâmica
-    - Mantenha trilha de auditoria completa para conformidade financeira
-  </Accordion>
-
-  <Accordion title="Atribuição Dinâmica do CRM" icon="database">
-    **Caso de Uso**: Direcione revisões para proprietários de conta do seu CRM
-
-    - Flow obtém email do proprietário da conta do CRM
-    - Armazene email no estado do flow (ex: `account_owner_email`)
-    - Use `assign_from_input` para direcionar automaticamente para a pessoa certa
-  </Accordion>
-
-  <Accordion title="Garantia de Qualidade" icon="magnifying-glass">
-    **Caso de Uso**: Validação de saída de IA antes da entrega ao cliente
-
-    - IA gera conteúdo ou respostas voltadas ao cliente
-    - Equipe de QA revisa via notificação por email
-    - Loops de feedback melhoram desempenho da IA ao longo do tempo
-  </Accordion>
-</AccordionGroup>
-
-## API de Webhooks
-
-Quando seus Flows pausam para feedback humano, você pode configurar webhooks para enviar dados da solicitação para sua própria aplicação. Isso permite:
-
-- Construir UIs de aprovação personalizadas
-- Integrar com ferramentas internas (Jira, ServiceNow, dashboards personalizados)
-- Rotear aprovações para sistemas de terceiros
-- Notificações em apps mobile
-- Sistemas de decisão automatizados
-
-<Frame>
-  <img src="/images/enterprise/hitl-settings-webhook.png" alt="Configuração de Webhook HITL" />
-</Frame>
-
-### Configurando Webhooks
-
-<Steps>
-  <Step title="Navegue até Configurações">
-    Vá para **Deployment** → **Settings** → **Human in the Loop**
-  </Step>
-  <Step title="Expanda a Seção Webhooks">
-    Clique para expandir a configuração de **Webhooks**
-  </Step>
-  <Step title="Adicione sua URL de Webhook">
-    Digite sua URL de webhook (deve ser HTTPS em produção)
-  </Step>
-  <Step title="Salve a Configuração">
-    Clique em **Salvar Configuração** para ativar
-  </Step>
-</Steps>
-
-Você pode configurar múltiplos webhooks. Cada webhook ativo recebe todos os eventos HITL.
-
-### Eventos de Webhook
-
-Seu endpoint receberá requisições HTTP POST para estes eventos:
-
-| Tipo de Evento | Quando é Disparado |
-|----------------|-------------------|
-| `new_request` | Um flow pausa e solicita feedback humano |
-
-### Payload do Webhook
-
-Todos os webhooks recebem um payload JSON com esta estrutura:
-
-```json
-{
-  "event": "new_request",
-  "request": {
-    "id": "550e8400-e29b-41d4-a716-446655440000",
-    "flow_id": "flow_abc123",
-    "method_name": "review_article",
-    "message": "Por favor, revise este artigo para publicação.",
-    "emit_options": ["approved", "rejected", "request_changes"],
-    "state": {
-      "article_id": 12345,
-      "author": "john@example.com",
-      "category": "technology"
-    },
-    "metadata": {},
-    "created_at": "2026-01-14T12:00:00Z"
-  },
-  "deployment": {
-    "id": 456,
-    "name": "Content Review Flow",
-    "organization_id": 789
-  },
-  "callback_url": "https://api.crewai.com/...",
-  "assigned_to_email": "reviewer@company.com"
-}
-```
-
-### Respondendo a Solicitações
-
-Para enviar feedback, **faça POST para a `callback_url`** incluída no payload do webhook.
-
-```http
-POST {callback_url}
-Content-Type: application/json
-
-{
-  "feedback": "Aprovado. Ótimo artigo!",
-  "source": "my_custom_app"
-}
-```
-
-### Segurança
-
-<Info>
-Todas as requisições de webhook são assinadas criptograficamente usando HMAC-SHA256 para garantir autenticidade e prevenir adulteração.
-</Info>
-
-#### Segurança do Webhook
-
-- **Assinaturas HMAC-SHA256**: Todo webhook inclui uma assinatura criptográfica
-- **Secrets por webhook**: Cada webhook tem seu próprio secret de assinatura único
-- **Criptografado em repouso**: Os secrets de assinatura são criptografados no nosso banco de dados
-- **Verificação de timestamp**: Previne ataques de replay
-
-#### Headers de Assinatura
-
-Cada requisição de webhook inclui estes headers:
-
-| Header | Descrição |
-|--------|-----------|
-| `X-Signature` | Assinatura HMAC-SHA256: `sha256=<hex_digest>` |
-| `X-Timestamp` | Timestamp Unix de quando a requisição foi assinada |
-
-#### Verificação
-
-Verifique computando:
-
-```python
-import hmac
-import hashlib
-
-expected = hmac.new(
-    signing_secret.encode(),
-    f"{timestamp}.{payload}".encode(),
-    hashlib.sha256
-).hexdigest()
-
-if hmac.compare_digest(expected, signature):
-    # Assinatura válida
-```
-
-### Tratamento de Erros
-
-Seu endpoint de webhook deve retornar um código de status 2xx para confirmar o recebimento:
-
-| Sua Resposta | Nosso Comportamento |
-|--------------|---------------------|
-| 2xx | Webhook entregue com sucesso |
-| 4xx/5xx | Registrado como falha, sem retry |
-| Timeout (30s) | Registrado como falha, sem retry |
-
-## Segurança e RBAC
-
-### Acesso ao Dashboard
-
-O acesso HITL é controlado no nível do deployment:
-
-| Permissão | Capacidade |
-|-----------|------------|
-| `manage_human_feedback` | Configurar settings HITL, ver todas as solicitações |
-| `respond_to_human_feedback` | Responder a solicitações, ver solicitações atribuídas |
-
-### Autorização de Resposta por Email
-
-Para respostas por email:
-1. O token reply-to codifica o email autorizado
-2. Email do remetente deve corresponder ao email do token
-3. Token não deve estar expirado (padrão 7 dias)
-4. Solicitação ainda deve estar pendente
-
-### Trilha de Auditoria
-
-Todas as ações HITL são registradas:
-- Criação de solicitação
-- Mudanças de atribuição
-- Submissão de resposta (com fonte: dashboard/email/API)
-- Status de retomada do flow
-
-## Solução de Problemas
-
-### Emails Não Enviando
-
-1. Verifique se "Notificações por Email" está ativado na configuração
-2. Verifique se as regras de roteamento correspondem ao nome do método
-3. Verifique se o email do responsável é válido
-4. Verifique o fallback do criador do deployment se nenhuma regra de roteamento corresponder
-
-### Respostas de Email Não Processando
-
-1. Verifique se o token não expirou (padrão 7 dias)
-2. Verifique se o email do remetente corresponde ao email atribuído
-3. Garanta que a solicitação ainda está pendente (não respondida ainda)
-
-### Flow Não Retomando
-
-1. Verifique o status da solicitação no dashboard
-2. Verifique se a URL de callback está acessível
-3. Garanta que o deployment ainda está rodando
-
-## Melhores Práticas
-
-<Tip>
-**Comece Simples**: Comece com notificações por email para o criador do deployment, depois adicione regras de roteamento conforme seus fluxos de trabalho amadurecem.
-</Tip>
-
-1. **Use Atribuição Dinâmica**: Obtenha emails de responsáveis do seu estado do flow para roteamento flexível.
-
-2. **Configure Resposta Automática**: Defina um fallback para revisões não críticas para evitar que flows fiquem travados.
-
-3. **Monitore Tempos de Resposta**: Use análises para identificar gargalos e otimizar seu processo de revisão.
-
-4. **Mantenha Mensagens de Revisão Claras**: Escreva mensagens claras e acionáveis no decorador `@human_feedback`.
-
-5. **Teste o Fluxo de Email**: Envie solicitações de teste para verificar a entrega de email antes de ir para produção.
-
-## Recursos Relacionados
-
-<CardGroup cols={2}>
-  <Card title="Feedback Humano em Flows" icon="code" href="/pt-BR/learn/human-feedback-in-flows">
-    Guia de implementação para o decorador `@human_feedback`
-  </Card>
-  <Card title="Guia de Workflow HITL para Flows" icon="route" href="/pt-BR/enterprise/guides/human-in-the-loop">
-    Guia passo a passo para configurar workflows HITL
-  </Card>
-  <Card title="Configuração RBAC" icon="shield-check" href="/pt-BR/enterprise/features/rbac">
-    Configure controle de acesso baseado em função para sua organização
-  </Card>
-  <Card title="Streaming de Webhook" icon="bolt" href="/pt-BR/enterprise/features/webhook-streaming">
-    Configure notificações de eventos em tempo real
-  </Card>
-</CardGroup>

docs/pt-BR/enterprise/guides/human-in-the-loop.mdx

@@ -5,54 +5,9 @@ icon: "user-check"
 mode: "wide"
 ---
 
-Human-In-The-Loop (HITL) é uma abordagem poderosa que combina inteligência artificial com expertise humana para aprimorar a tomada de decisão e melhorar os resultados das tarefas. Este guia mostra como implementar HITL dentro do CrewAI Enterprise.
+Human-In-The-Loop (HITL) é uma abordagem poderosa que combina inteligência artificial com expertise humana para aprimorar a tomada de decisão e melhorar os resultados das tarefas. Este guia mostra como implementar HITL dentro do CrewAI.
 
-## Abordagens HITL no CrewAI
-
-CrewAI oferece duas abordagens para implementar workflows human-in-the-loop:
-
-| Abordagem | Melhor Para | Versão |
-|----------|----------|---------|
-| **Baseada em Flow** (decorador `@human_feedback`) | Produção com UI Enterprise, workflows email-first, recursos completos da plataforma | **1.8.0+** |
-| **Baseada em Webhook** | Integrações customizadas, sistemas externos (Slack, Teams, etc.), configurações legadas | Todas as versões |
-
-## HITL Baseado em Flow com Plataforma Enterprise
-
-<Note>
-O decorador `@human_feedback` requer **CrewAI versão 1.8.0 ou superior**.
-</Note>
-
-Ao usar o decorador `@human_feedback` em seus Flows, o CrewAI Enterprise oferece um **sistema HITL email-first** que permite que qualquer pessoa com um endereço de email responda a solicitações de revisão:
-
-<CardGroup cols={2}>
-  <Card title="Design Email-First" icon="envelope">
-    Respondentes recebem notificações por email e podem responder diretamente—nenhum login necessário.
-  </Card>
-  <Card title="Revisão no Dashboard" icon="desktop">
-    Revise e responda a solicitações HITL no dashboard Enterprise quando preferir.
-  </Card>
-  <Card title="Roteamento Flexível" icon="route">
-    Direcione solicitações para emails específicos com base em padrões de método ou obtenha do estado do flow.
-  </Card>
-  <Card title="Resposta Automática" icon="clock">
-    Configure respostas automáticas de fallback quando nenhum humano responder dentro do timeout.
-  </Card>
-</CardGroup>
-
-### Principais Benefícios
-
-- **Respondentes externos**: Qualquer pessoa com email pode responder, mesmo não sendo usuário da plataforma
-- **Atribuição dinâmica**: Obtenha o email do responsável do estado do flow (ex: `account_owner_email`)
-- **Configuração simples**: Roteamento baseado em email é mais fácil de configurar do que gerenciamento de usuários/funções
-- **Fallback do criador do deployment**: Se nenhuma regra de roteamento corresponder, o criador do deployment é notificado
-
-<Tip>
-Para detalhes de implementação do decorador `@human_feedback`, consulte o guia [Feedback Humano em Flows](/pt-BR/learn/human-feedback-in-flows).
-</Tip>
-
-## Configurando Workflows HITL Baseados em Webhook
-
-Para integrações customizadas com sistemas externos como Slack, Microsoft Teams ou suas próprias aplicações, você pode usar a abordagem baseada em webhook:
+## Configurando Workflows HITL
 
 <Steps>
     <Step title="Configure Sua Tarefa">
@@ -144,14 +99,3 @@ Workflows HITL são particularmente valiosos para:
 - Operações sensíveis ou de alto risco
 - Tarefas criativas que exigem julgamento humano
 - Revisões de conformidade e regulatórias
-
-## Saiba Mais
-
-<CardGroup cols={2}>
-  <Card title="Gerenciamento HITL para Flows" icon="users-gear" href="/pt-BR/enterprise/features/flow-hitl-management">
-    Explore os recursos completos da plataforma HITL para Flows, incluindo notificações por email, regras de roteamento, resposta automática e análises.
-  </Card>
-  <Card title="Feedback Humano em Flows" icon="code" href="/pt-BR/learn/human-feedback-in-flows">
-    Guia de implementação para o decorador `@human_feedback` em seus Flows.
-  </Card>
-</CardGroup>

docs/pt-BR/learn/human-in-the-loop.mdx

@@ -112,9 +112,3 @@ Workflows HITL são particularmente valiosos para:
 - Operações sensíveis ou de alto risco
 - Tarefas criativas que requerem julgamento humano
 - Revisões de conformidade e regulamentação
-
-## Recursos Enterprise
-
-<Card title="Plataforma de Gerenciamento HITL para Flows" icon="users-gear" href="/pt-BR/enterprise/features/flow-hitl-management">
-  O CrewAI Enterprise oferece um sistema abrangente de gerenciamento HITL para Flows com revisão na plataforma, atribuição de respondentes, permissões, políticas de escalação, gerenciamento de SLA, roteamento dinâmico e análises completas. [Saiba mais →](/pt-BR/enterprise/features/flow-hitl-management)
-</Card>

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

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

lib/crewai-tools/pyproject.toml

@@ -12,7 +12,7 @@ dependencies = [
     "pytube~=15.0.0",
     "requests~=2.32.5",
     "docker~=7.1.0",
-    "crewai==1.9.3",
+    "crewai==1.8.1",
     "lancedb~=0.5.4",
     "tiktoken~=0.8.0",
     "beautifulsoup4~=4.13.4",

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

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

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

@@ -1,11 +1,10 @@
 """Crewai Enterprise Tools."""
-
-import json
 import os
-from typing import Any
+import json
+import re
+from typing import Any, Optional, Union, cast, get_origin
 
 from crewai.tools import BaseTool
-from crewai.utilities.pydantic_schema_utils import create_model_from_schema
 from pydantic import Field, create_model
 import requests
 
@@ -15,6 +14,77 @@ from crewai_tools.tools.crewai_platform_tools.misc import (
 )
 
 
+class AllOfSchemaAnalyzer:
+    """Helper class to analyze and merge allOf schemas."""
+
+    def __init__(self, schemas: list[dict[str, Any]]):
+        self.schemas = schemas
+        self._explicit_types: list[str] = []
+        self._merged_properties: dict[str, Any] = {}
+        self._merged_required: list[str] = []
+        self._analyze_schemas()
+
+    def _analyze_schemas(self) -> None:
+        """Analyze all schemas and extract relevant information."""
+        for schema in self.schemas:
+            if "type" in schema:
+                self._explicit_types.append(schema["type"])
+
+            # Merge object properties
+            if schema.get("type") == "object" and "properties" in schema:
+                self._merged_properties.update(schema["properties"])
+                if "required" in schema:
+                    self._merged_required.extend(schema["required"])
+
+    def has_consistent_type(self) -> bool:
+        """Check if all schemas have the same explicit type."""
+        return len(set(self._explicit_types)) == 1 if self._explicit_types else False
+
+    def get_consistent_type(self) -> type[Any]:
+        """Get the consistent type if all schemas agree."""
+        if not self.has_consistent_type():
+            raise ValueError("No consistent type found")
+
+        type_mapping = {
+            "string": str,
+            "integer": int,
+            "number": float,
+            "boolean": bool,
+            "array": list,
+            "object": dict,
+            "null": type(None),
+        }
+        return type_mapping.get(self._explicit_types[0], str)
+
+    def has_object_schemas(self) -> bool:
+        """Check if any schemas are object types with properties."""
+        return bool(self._merged_properties)
+
+    def get_merged_properties(self) -> dict[str, Any]:
+        """Get merged properties from all object schemas."""
+        return self._merged_properties
+
+    def get_merged_required_fields(self) -> list[str]:
+        """Get merged required fields from all object schemas."""
+        return list(set(self._merged_required))  # Remove duplicates
+
+    def get_fallback_type(self) -> type[Any]:
+        """Get a fallback type when merging fails."""
+        if self._explicit_types:
+            # Use the first explicit type
+            type_mapping = {
+                "string": str,
+                "integer": int,
+                "number": float,
+                "boolean": bool,
+                "array": list,
+                "object": dict,
+                "null": type(None),
+            }
+            return type_mapping.get(self._explicit_types[0], str)
+        return str
+
+
 class CrewAIPlatformActionTool(BaseTool):
     action_name: str = Field(default="", description="The name of the action")
     action_schema: dict[str, Any] = Field(
@@ -27,19 +97,42 @@ class CrewAIPlatformActionTool(BaseTool):
         action_name: str,
         action_schema: dict[str, Any],
     ):
-        parameters = action_schema.get("function", {}).get("parameters", {})
+        self._model_registry: dict[str, type[Any]] = {}
+        self._base_name = self._sanitize_name(action_name)
+
+        schema_props, required = self._extract_schema_info(action_schema)
+
+        field_definitions: dict[str, Any] = {}
+        for param_name, param_details in schema_props.items():
+            param_desc = param_details.get("description", "")
+            is_required = param_name in required
 
-        if parameters and parameters.get("properties"):
             try:
-                if "title" not in parameters:
-                    parameters = {**parameters, "title": f"{action_name}Schema"}
-                if "type" not in parameters:
-                    parameters = {**parameters, "type": "object"}
-                args_schema = create_model_from_schema(parameters)
+                field_type = self._process_schema_type(
+                    param_details, self._sanitize_name(param_name).title()
+                )
             except Exception:
-                args_schema = create_model(f"{action_name}Schema")
+                field_type = str
+
+            field_definitions[param_name] = self._create_field_definition(
+                field_type, is_required, param_desc
+            )
+
+        if field_definitions:
+            try:
+                args_schema = create_model(
+                    f"{self._base_name}Schema", **field_definitions
+                )
+            except Exception:
+                args_schema = create_model(
+                    f"{self._base_name}Schema",
+                    input_text=(str, Field(description="Input for the action")),
+                )
         else:
-            args_schema = create_model(f"{action_name}Schema")
+            args_schema = create_model(
+                f"{self._base_name}Schema",
+                input_text=(str, Field(description="Input for the action")),
+            )
 
         super().__init__(
             name=action_name.lower().replace(" ", "_"),
@@ -49,12 +142,285 @@ class CrewAIPlatformActionTool(BaseTool):
         self.action_name = action_name
         self.action_schema = action_schema
 
-    def _run(self, **kwargs: Any) -> str:
+    @staticmethod
+    def _sanitize_name(name: str) -> str:
+        name = name.lower().replace(" ", "_")
+        sanitized = re.sub(r"[^a-zA-Z0-9_]", "", name)
+        parts = sanitized.split("_")
+        return "".join(word.capitalize() for word in parts if word)
+
+    @staticmethod
+    def _extract_schema_info(
+        action_schema: dict[str, Any],
+    ) -> tuple[dict[str, Any], list[str]]:
+        schema_props = (
+            action_schema.get("function", {})
+            .get("parameters", {})
+            .get("properties", {})
+        )
+        required = (
+            action_schema.get("function", {}).get("parameters", {}).get("required", [])
+        )
+        return schema_props, required
+
+    def _process_schema_type(self, schema: dict[str, Any], type_name: str) -> type[Any]:
+        """
+        Process a JSON Schema type definition into a Python type.
+
+        Handles complex schema constructs like anyOf, oneOf, allOf, enums, arrays, and objects.
+        """
+        # Handle composite schema types (anyOf, oneOf, allOf)
+        if composite_type := self._process_composite_schema(schema, type_name):
+            return composite_type
+
+        # Handle primitive types and simple constructs
+        return self._process_primitive_schema(schema, type_name)
+
+    def _process_composite_schema(
+        self, schema: dict[str, Any], type_name: str
+    ) -> type[Any] | None:
+        """Process composite schema types: anyOf, oneOf, allOf."""
+        if "anyOf" in schema:
+            return self._process_any_of_schema(schema["anyOf"], type_name)
+        if "oneOf" in schema:
+            return self._process_one_of_schema(schema["oneOf"], type_name)
+        if "allOf" in schema:
+            return self._process_all_of_schema(schema["allOf"], type_name)
+        return None
+
+    def _process_any_of_schema(
+        self, any_of_types: list[dict[str, Any]], type_name: str
+    ) -> type[Any]:
+        """Process anyOf schema - creates Union of possible types."""
+        is_nullable = any(t.get("type") == "null" for t in any_of_types)
+        non_null_types = [t for t in any_of_types if t.get("type") != "null"]
+
+        if not non_null_types:
+            return cast(
+                type[Any], cast(object, str | None)
+            )  # fallback for only-null case
+
+        base_type = (
+            self._process_schema_type(non_null_types[0], type_name)
+            if len(non_null_types) == 1
+            else self._create_union_type(non_null_types, type_name, "AnyOf")
+        )
+        return base_type | None if is_nullable else base_type  # type: ignore[return-value]
+
+    def _process_one_of_schema(
+        self, one_of_types: list[dict[str, Any]], type_name: str
+    ) -> type[Any]:
+        """Process oneOf schema - creates Union of mutually exclusive types."""
+        return (
+            self._process_schema_type(one_of_types[0], type_name)
+            if len(one_of_types) == 1
+            else self._create_union_type(one_of_types, type_name, "OneOf")
+        )
+
+    def _process_all_of_schema(
+        self, all_of_schemas: list[dict[str, Any]], type_name: str
+    ) -> type[Any]:
+        """Process allOf schema - merges schemas that must all be satisfied."""
+        if len(all_of_schemas) == 1:
+            return self._process_schema_type(all_of_schemas[0], type_name)
+        return self._merge_all_of_schemas(all_of_schemas, type_name)
+
+    def _create_union_type(
+        self, schemas: list[dict[str, Any]], type_name: str, prefix: str
+    ) -> type[Any]:
+        """Create a Union type from multiple schemas."""
+        return Union[  # type: ignore  # noqa: UP007
+            tuple(
+                self._process_schema_type(schema, f"{type_name}{prefix}{i}")
+                for i, schema in enumerate(schemas)
+            )
+        ]
+
+    def _process_primitive_schema(
+        self, schema: dict[str, Any], type_name: str
+    ) -> type[Any]:
+        """Process primitive schema types: string, number, array, object, etc."""
+        json_type = schema.get("type", "string")
+
+        if "enum" in schema:
+            return self._process_enum_schema(schema, json_type)
+
+        if json_type == "array":
+            return self._process_array_schema(schema, type_name)
+
+        if json_type == "object":
+            return self._create_nested_model(schema, type_name)
+
+        return self._map_json_type_to_python(json_type)
+
+    def _process_enum_schema(self, schema: dict[str, Any], json_type: str) -> type[Any]:
+        """Process enum schema - currently falls back to base type."""
+        enum_values = schema["enum"]
+        if not enum_values:
+            return self._map_json_type_to_python(json_type)
+
+        # For Literal types, we need to pass the values directly, not as a tuple
+        # This is a workaround since we can't dynamically create Literal types easily
+        # Fall back to the base JSON type for now
+        return self._map_json_type_to_python(json_type)
+
+    def _process_array_schema(
+        self, schema: dict[str, Any], type_name: str
+    ) -> type[Any]:
+        items_schema = schema.get("items", {"type": "string"})
+        item_type = self._process_schema_type(items_schema, f"{type_name}Item")
+        return list[item_type]  # type: ignore
+
+    def _merge_all_of_schemas(
+        self, schemas: list[dict[str, Any]], type_name: str
+    ) -> type[Any]:
+        schema_analyzer = AllOfSchemaAnalyzer(schemas)
+
+        if schema_analyzer.has_consistent_type():
+            return schema_analyzer.get_consistent_type()
+
+        if schema_analyzer.has_object_schemas():
+            return self._create_merged_object_model(
+                schema_analyzer.get_merged_properties(),
+                schema_analyzer.get_merged_required_fields(),
+                type_name,
+            )
+
+        return schema_analyzer.get_fallback_type()
+
+    def _create_merged_object_model(
+        self, properties: dict[str, Any], required: list[str], model_name: str
+    ) -> type[Any]:
+        full_model_name = f"{self._base_name}{model_name}AllOf"
+
+        if full_model_name in self._model_registry:
+            return self._model_registry[full_model_name]
+
+        if not properties:
+            return dict
+
+        field_definitions = self._build_field_definitions(
+            properties, required, model_name
+        )
+
+        try:
+            merged_model = create_model(full_model_name, **field_definitions)
+            self._model_registry[full_model_name] = merged_model
+            return merged_model
+        except Exception:
+            return dict
+
+    def _build_field_definitions(
+        self, properties: dict[str, Any], required: list[str], model_name: str
+    ) -> dict[str, Any]:
+        field_definitions = {}
+
+        for prop_name, prop_schema in properties.items():
+            prop_desc = prop_schema.get("description", "")
+            is_required = prop_name in required
+
+            try:
+                prop_type = self._process_schema_type(
+                    prop_schema, f"{model_name}{self._sanitize_name(prop_name).title()}"
+                )
+            except Exception:
+                prop_type = str
+
+            field_definitions[prop_name] = self._create_field_definition(
+                prop_type, is_required, prop_desc
+            )
+
+        return field_definitions
+
+    def _create_nested_model(
+        self, schema: dict[str, Any], model_name: str
+    ) -> type[Any]:
+        full_model_name = f"{self._base_name}{model_name}"
+
+        if full_model_name in self._model_registry:
+            return self._model_registry[full_model_name]
+
+        properties = schema.get("properties", {})
+        required_fields = schema.get("required", [])
+
+        if not properties:
+            return dict
+
+        field_definitions = {}
+        for prop_name, prop_schema in properties.items():
+            prop_desc = prop_schema.get("description", "")
+            is_required = prop_name in required_fields
+
+            try:
+                prop_type = self._process_schema_type(
+                    prop_schema, f"{model_name}{self._sanitize_name(prop_name).title()}"
+                )
+            except Exception:
+                prop_type = str
+
+            field_definitions[prop_name] = self._create_field_definition(
+                prop_type, is_required, prop_desc
+            )
+
+        try:
+            nested_model = create_model(full_model_name, **field_definitions)  # type: ignore
+            self._model_registry[full_model_name] = nested_model
+            return nested_model
+        except Exception:
+            return dict
+
+    def _create_field_definition(
+        self, field_type: type[Any], is_required: bool, description: str
+    ) -> tuple:
+        if is_required:
+            return (field_type, Field(description=description))
+        if get_origin(field_type) is Union:
+            return (field_type, Field(default=None, description=description))
+        return (
+            Optional[field_type],  # noqa: UP045
+            Field(default=None, description=description),
+        )
+
+    def _map_json_type_to_python(self, json_type: str) -> type[Any]:
+        type_mapping = {
+            "string": str,
+            "integer": int,
+            "number": float,
+            "boolean": bool,
+            "array": list,
+            "object": dict,
+            "null": type(None),
+        }
+        return type_mapping.get(json_type, str)
+
+    def _get_required_nullable_fields(self) -> list[str]:
+        schema_props, required = self._extract_schema_info(self.action_schema)
+
+        required_nullable_fields = []
+        for param_name in required:
+            param_details = schema_props.get(param_name, {})
+            if self._is_nullable_type(param_details):
+                required_nullable_fields.append(param_name)
+
+        return required_nullable_fields
+
+    def _is_nullable_type(self, schema: dict[str, Any]) -> bool:
+        if "anyOf" in schema:
+            return any(t.get("type") == "null" for t in schema["anyOf"])
+        return schema.get("type") == "null"
+
+    def _run(self, **kwargs) -> str:
         try:
             cleaned_kwargs = {
                 key: value for key, value in kwargs.items() if value is not None
             }
 
+            required_nullable_fields = self._get_required_nullable_fields()
+
+            for field_name in required_nullable_fields:
+                if field_name not in cleaned_kwargs:
+                    cleaned_kwargs[field_name] = None
+
             api_url = (
                 f"{get_platform_api_base_url()}/actions/{self.action_name}/execute"
             )
@@ -63,9 +429,7 @@ class CrewAIPlatformActionTool(BaseTool):
                 "Authorization": f"Bearer {token}",
                 "Content-Type": "application/json",
             }
-            payload = {
-                "integration": cleaned_kwargs if cleaned_kwargs else {"_noop": True}
-            }
+            payload = cleaned_kwargs
 
             response = requests.post(
                 url=api_url,
@@ -77,14 +441,7 @@ class CrewAIPlatformActionTool(BaseTool):
 
             data = response.json()
             if not response.ok:
-                if isinstance(data, dict):
-                    error_info = data.get("error", {})
-                    if isinstance(error_info, dict):
-                        error_message = error_info.get("message", json.dumps(data))
-                    else:
-                        error_message = str(error_info)
-                else:
-                    error_message = str(data)
+                error_message = data.get("error", {}).get("message", json.dumps(data))
                 return f"API request failed: {error_message}"
 
             return json.dumps(data, indent=2)

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

@@ -1,10 +1,5 @@
-"""CrewAI platform tool builder for fetching and creating action tools."""
-
-import logging
-import os
-from types import TracebackType
 from typing import Any
-
+import os
 from crewai.tools import BaseTool
 import requests
 
@@ -17,29 +12,22 @@ from crewai_tools.tools.crewai_platform_tools.misc import (
 )
 
 
-logger = logging.getLogger(__name__)
-
-
 class CrewaiPlatformToolBuilder:
-    """Builds platform tools from remote action schemas."""
-
     def __init__(
         self,
         apps: list[str],
-    ) -> None:
+    ):
         self._apps = apps
-        self._actions_schema: dict[str, dict[str, Any]] = {}
-        self._tools: list[BaseTool] | None = None
+        self._actions_schema = {}  # type: ignore[var-annotated]
+        self._tools = None
 
     def tools(self) -> list[BaseTool]:
-        """Fetch actions and return built tools."""
         if self._tools is None:
             self._fetch_actions()
             self._create_tools()
         return self._tools if self._tools is not None else []
 
-    def _fetch_actions(self) -> None:
-        """Fetch action schemas from the platform API."""
+    def _fetch_actions(self):
         actions_url = f"{get_platform_api_base_url()}/actions"
         headers = {"Authorization": f"Bearer {get_platform_integration_token()}"}
 
@@ -52,8 +40,7 @@ class CrewaiPlatformToolBuilder:
                 verify=os.environ.get("CREWAI_FACTORY", "false").lower() != "true",
             )
             response.raise_for_status()
-        except Exception as e:
-            logger.error(f"Failed to fetch platform tools for apps {self._apps}: {e}")
+        except Exception:
             return
 
         raw_data = response.json()
@@ -64,8 +51,6 @@ class CrewaiPlatformToolBuilder:
         for app, action_list in action_categories.items():
             if isinstance(action_list, list):
                 for action in action_list:
-                    if not isinstance(action, dict):
-                        continue
                     if action_name := action.get("name"):
                         action_schema = {
                             "function": {
@@ -79,16 +64,72 @@ class CrewaiPlatformToolBuilder:
                         }
                         self._actions_schema[action_name] = action_schema
 
-    def _create_tools(self) -> None:
-        """Create tool instances from fetched action schemas."""
-        tools: list[BaseTool] = []
+    def _generate_detailed_description(
+        self, schema: dict[str, Any], indent: int = 0
+    ) -> list[str]:
+        descriptions = []
+        indent_str = "  " * indent
+
+        schema_type = schema.get("type", "string")
+
+        if schema_type == "object":
+            properties = schema.get("properties", {})
+            required_fields = schema.get("required", [])
+
+            if properties:
+                descriptions.append(f"{indent_str}Object with properties:")
+                for prop_name, prop_schema in properties.items():
+                    prop_desc = prop_schema.get("description", "")
+                    is_required = prop_name in required_fields
+                    req_str = " (required)" if is_required else " (optional)"
+                    descriptions.append(
+                        f"{indent_str}  - {prop_name}: {prop_desc}{req_str}"
+                    )
+
+                    if prop_schema.get("type") == "object":
+                        descriptions.extend(
+                            self._generate_detailed_description(prop_schema, indent + 2)
+                        )
+                    elif prop_schema.get("type") == "array":
+                        items_schema = prop_schema.get("items", {})
+                        if items_schema.get("type") == "object":
+                            descriptions.append(f"{indent_str}    Array of objects:")
+                            descriptions.extend(
+                                self._generate_detailed_description(
+                                    items_schema, indent + 3
+                                )
+                            )
+                        elif "enum" in items_schema:
+                            descriptions.append(
+                                f"{indent_str}    Array of enum values: {items_schema['enum']}"
+                            )
+                    elif "enum" in prop_schema:
+                        descriptions.append(
+                            f"{indent_str}    Enum values: {prop_schema['enum']}"
+                        )
+
+        return descriptions
+
+    def _create_tools(self):
+        tools = []
 
         for action_name, action_schema in self._actions_schema.items():
             function_details = action_schema.get("function", {})
             description = function_details.get("description", f"Execute {action_name}")
 
+            parameters = function_details.get("parameters", {})
+            param_descriptions = []
+
+            if parameters.get("properties"):
+                param_descriptions.append("\nDetailed Parameter Structure:")
+                param_descriptions.extend(
+                    self._generate_detailed_description(parameters)
+                )
+
+            full_description = description + "\n".join(param_descriptions)
+
             tool = CrewAIPlatformActionTool(
-                description=description,
+                description=full_description,
                 action_name=action_name,
                 action_schema=action_schema,
             )
@@ -97,14 +138,8 @@ class CrewaiPlatformToolBuilder:
 
         self._tools = tools
 
-    def __enter__(self) -> list[BaseTool]:
-        """Enter context manager and return tools."""
+    def __enter__(self):
         return self.tools()
 
-    def __exit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_val: BaseException | None,
-        exc_tb: TracebackType | None,
-    ) -> None:
-        """Exit context manager."""
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        pass

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

@@ -137,7 +137,6 @@ class StagehandTool(BaseTool):
     - 'observe': For finding elements in a specific area
     """
     args_schema: type[BaseModel] = StagehandToolSchema
-    package_dependencies: list[str] = Field(default_factory=lambda: ["stagehand"])
 
     # Stagehand configuration
     api_key: str | None = None

lib/crewai-tools/tests/tools/crewai_platform_tools/test_crewai_platform_action_tool.py

@@ -1,3 +1,4 @@
+from typing import Union, get_args, get_origin
 from unittest.mock import patch, Mock
 import os
 
@@ -6,6 +7,251 @@ from crewai_tools.tools.crewai_platform_tools.crewai_platform_action_tool import
 )
 
 
+class TestSchemaProcessing:
+
+    def setup_method(self):
+        self.base_action_schema = {
+            "function": {
+                "parameters": {
+                    "properties": {},
+                    "required": []
+                }
+            }
+        }
+
+    def create_test_tool(self, action_name="test_action"):
+        return CrewAIPlatformActionTool(
+            description="Test tool",
+            action_name=action_name,
+            action_schema=self.base_action_schema
+        )
+
+    def test_anyof_multiple_types(self):
+        tool = self.create_test_tool()
+
+        test_schema = {
+            "anyOf": [
+                {"type": "string"},
+                {"type": "number"},
+                {"type": "integer"}
+            ]
+        }
+
+        result_type = tool._process_schema_type(test_schema, "TestField")
+
+        assert get_origin(result_type) is Union
+
+        args = get_args(result_type)
+        expected_types = (str, float, int)
+
+        for expected_type in expected_types:
+            assert expected_type in args
+
+    def test_anyof_with_null(self):
+        tool = self.create_test_tool()
+
+        test_schema = {
+            "anyOf": [
+                {"type": "string"},
+                {"type": "number"},
+                {"type": "null"}
+            ]
+        }
+
+        result_type = tool._process_schema_type(test_schema, "TestFieldNullable")
+
+        assert get_origin(result_type) is Union
+
+        args = get_args(result_type)
+        assert type(None) in args
+        assert str in args
+        assert float in args
+
+    def test_anyof_single_type(self):
+        tool = self.create_test_tool()
+
+        test_schema = {
+            "anyOf": [
+                {"type": "string"}
+            ]
+        }
+
+        result_type = tool._process_schema_type(test_schema, "TestFieldSingle")
+
+        assert result_type is str
+
+    def test_oneof_multiple_types(self):
+        tool = self.create_test_tool()
+
+        test_schema = {
+            "oneOf": [
+                {"type": "string"},
+                {"type": "boolean"}
+            ]
+        }
+
+        result_type = tool._process_schema_type(test_schema, "TestFieldOneOf")
+
+        assert get_origin(result_type) is Union
+
+        args = get_args(result_type)
+        expected_types = (str, bool)
+
+        for expected_type in expected_types:
+            assert expected_type in args
+
+    def test_oneof_single_type(self):
+        tool = self.create_test_tool()
+
+        test_schema = {
+            "oneOf": [
+                {"type": "integer"}
+            ]
+        }
+
+        result_type = tool._process_schema_type(test_schema, "TestFieldOneOfSingle")
+
+        assert result_type is int
+
+    def test_basic_types(self):
+        tool = self.create_test_tool()
+
+        test_cases = [
+            ({"type": "string"}, str),
+            ({"type": "integer"}, int),
+            ({"type": "number"}, float),
+            ({"type": "boolean"}, bool),
+            ({"type": "array", "items": {"type": "string"}}, list),
+        ]
+
+        for schema, expected_type in test_cases:
+            result_type = tool._process_schema_type(schema, "TestField")
+            if schema["type"] == "array":
+                assert get_origin(result_type) is list
+            else:
+                assert result_type is expected_type
+
+    def test_enum_handling(self):
+        tool = self.create_test_tool()
+
+        test_schema = {
+            "type": "string",
+            "enum": ["option1", "option2", "option3"]
+        }
+
+        result_type = tool._process_schema_type(test_schema, "TestFieldEnum")
+
+        assert result_type is str
+
+    def test_nested_anyof(self):
+        tool = self.create_test_tool()
+
+        test_schema = {
+            "anyOf": [
+                {"type": "string"},
+                {
+                    "anyOf": [
+                        {"type": "integer"},
+                        {"type": "boolean"}
+                    ]
+                }
+            ]
+        }
+
+        result_type = tool._process_schema_type(test_schema, "TestFieldNested")
+
+        assert get_origin(result_type) is Union
+        args = get_args(result_type)
+
+        assert str in args
+
+        if len(args) == 3:
+            assert int in args
+            assert bool in args
+        else:
+            nested_union = next(arg for arg in args if get_origin(arg) is Union)
+            nested_args = get_args(nested_union)
+            assert int in nested_args
+            assert bool in nested_args
+
+    def test_allof_same_types(self):
+        tool = self.create_test_tool()
+
+        test_schema = {
+            "allOf": [
+                {"type": "string"},
+                {"type": "string", "maxLength": 100}
+            ]
+        }
+
+        result_type = tool._process_schema_type(test_schema, "TestFieldAllOfSame")
+
+        assert result_type is str
+
+    def test_allof_object_merge(self):
+        tool = self.create_test_tool()
+
+        test_schema = {
+            "allOf": [
+                {
+                    "type": "object",
+                    "properties": {
+                        "name": {"type": "string"},
+                        "age": {"type": "integer"}
+                    },
+                    "required": ["name"]
+                },
+                {
+                    "type": "object",
+                    "properties": {
+                        "email": {"type": "string"},
+                            "age": {"type": "integer"}
+                    },
+                    "required": ["email"]
+                }
+            ]
+        }
+
+        result_type = tool._process_schema_type(test_schema, "TestFieldAllOfMerged")
+
+        # Should create a merged model with all properties
+        # The implementation might fall back to dict if model creation fails
+        # Let's just verify it's not a basic scalar type
+        assert result_type is not str
+        assert result_type is not int
+        assert result_type is not bool
+        # It could be dict (fallback) or a proper model class
+        assert result_type in (dict, type) or hasattr(result_type, '__name__')
+
+    def test_allof_single_schema(self):
+        """Test that allOf with single schema works correctly."""
+        tool = self.create_test_tool()
+
+        test_schema = {
+            "allOf": [
+                {"type": "boolean"}
+            ]
+        }
+
+        result_type = tool._process_schema_type(test_schema, "TestFieldAllOfSingle")
+
+        # Should be just bool
+        assert result_type is bool
+
+    def test_allof_mixed_types(self):
+        tool = self.create_test_tool()
+
+        test_schema = {
+            "allOf": [
+                {"type": "string"},
+                {"type": "integer"}
+            ]
+        }
+
+        result_type = tool._process_schema_type(test_schema, "TestFieldAllOfMixed")
+
+        assert result_type is str
+
 class TestCrewAIPlatformActionToolVerify:
     """Test suite for SSL verification behavior based on CREWAI_FACTORY environment variable"""
 

lib/crewai-tools/tests/tools/crewai_platform_tools/test_crewai_platform_tool_builder.py

@@ -224,6 +224,43 @@ class TestCrewaiPlatformToolBuilder(unittest.TestCase):
             _, kwargs = mock_get.call_args
             assert kwargs["params"]["apps"] == ""
 
+    def test_detailed_description_generation(self):
+        builder = CrewaiPlatformToolBuilder(apps=["test"])
+
+        complex_schema = {
+            "type": "object",
+            "properties": {
+                "simple_string": {"type": "string", "description": "A simple string"},
+                "nested_object": {
+                    "type": "object",
+                    "properties": {
+                        "inner_prop": {
+                            "type": "integer",
+                            "description": "Inner property",
+                        }
+                    },
+                    "description": "Nested object",
+                },
+                "array_prop": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "Array of strings",
+                },
+            },
+        }
+
+        descriptions = builder._generate_detailed_description(complex_schema)
+
+        assert isinstance(descriptions, list)
+        assert len(descriptions) > 0
+
+        description_text = "\n".join(descriptions)
+        assert "simple_string" in description_text
+        assert "nested_object" in description_text
+        assert "array_prop" in description_text
+
+
+
 class TestCrewaiPlatformToolBuilderVerify(unittest.TestCase):
     """Test suite for SSL verification behavior in CrewaiPlatformToolBuilder"""
 

lib/crewai/pyproject.toml

@@ -49,7 +49,7 @@ Repository = "https://github.com/crewAIInc/crewAI"
 
 [project.optional-dependencies]
 tools = [
-    "crewai-tools==1.9.3",
+    "crewai-tools==1.8.1",
 ]
 embeddings = [
     "tiktoken~=0.8.0"
@@ -90,7 +90,7 @@ azure-ai-inference = [
     "azure-ai-inference~=1.0.0b9",
 ]
 anthropic = [
-    "anthropic~=0.73.0",
+    "anthropic~=0.71.0",
 ]
 a2a = [
      "a2a-sdk~=0.3.10",

lib/crewai/src/crewai/__init__.py

@@ -40,7 +40,7 @@ def _suppress_pydantic_deprecation_warnings() -> None:
 
 _suppress_pydantic_deprecation_warnings()
 
-__version__ = "1.9.3"
+__version__ = "1.8.1"
 _telemetry_submitted = False
 
 

lib/crewai/src/crewai/a2a/auth/__init__.py

@@ -1,36 +1,20 @@
 """A2A authentication schemas."""
 
-from crewai.a2a.auth.client_schemes import (
+from crewai.a2a.auth.schemas import (
     APIKeyAuth,
-    AuthScheme,
     BearerTokenAuth,
-    ClientAuthScheme,
     HTTPBasicAuth,
     HTTPDigestAuth,
     OAuth2AuthorizationCode,
     OAuth2ClientCredentials,
-    TLSConfig,
-)
-from crewai.a2a.auth.server_schemes import (
-    AuthenticatedUser,
-    OIDCAuth,
-    ServerAuthScheme,
-    SimpleTokenAuth,
 )
 
 
 __all__ = [
     "APIKeyAuth",
-    "AuthScheme",
-    "AuthenticatedUser",
     "BearerTokenAuth",
-    "ClientAuthScheme",
     "HTTPBasicAuth",
     "HTTPDigestAuth",
     "OAuth2AuthorizationCode",
     "OAuth2ClientCredentials",
-    "OIDCAuth",
-    "ServerAuthScheme",
-    "SimpleTokenAuth",
-    "TLSConfig",
 ]

lib/crewai/src/crewai/a2a/auth/client_schemes.py

@@ -1,550 +0,0 @@
-"""Authentication schemes for A2A protocol clients.
-
-Supported authentication methods:
-- Bearer tokens
-- OAuth2 (Client Credentials, Authorization Code)
-- API Keys (header, query, cookie)
-- HTTP Basic authentication
-- HTTP Digest authentication
-- mTLS (mutual TLS) client certificate authentication
-"""
-
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-import asyncio
-import base64
-from collections.abc import Awaitable, Callable, MutableMapping
-from pathlib import Path
-import ssl
-import time
-from typing import TYPE_CHECKING, ClassVar, Literal
-import urllib.parse
-
-import httpx
-from httpx import DigestAuth
-from pydantic import BaseModel, ConfigDict, Field, FilePath, PrivateAttr
-from typing_extensions import deprecated
-
-
-if TYPE_CHECKING:
-    import grpc  # type: ignore[import-untyped]
-
-
-class TLSConfig(BaseModel):
-    """TLS/mTLS configuration for secure client connections.
-
-    Supports mutual TLS (mTLS) where the client presents a certificate to the server,
-    and standard TLS with custom CA verification.
-
-    Attributes:
-        client_cert_path: Path to client certificate file (PEM format) for mTLS.
-        client_key_path: Path to client private key file (PEM format) for mTLS.
-        ca_cert_path: Path to CA certificate bundle for server verification.
-        verify: Whether to verify server certificates. Set False only for development.
-    """
-
-    model_config: ClassVar[ConfigDict] = ConfigDict(extra="forbid")
-
-    client_cert_path: FilePath | None = Field(
-        default=None,
-        description="Path to client certificate file (PEM format) for mTLS",
-    )
-    client_key_path: FilePath | None = Field(
-        default=None,
-        description="Path to client private key file (PEM format) for mTLS",
-    )
-    ca_cert_path: FilePath | None = Field(
-        default=None,
-        description="Path to CA certificate bundle for server verification",
-    )
-    verify: bool = Field(
-        default=True,
-        description="Whether to verify server certificates. Set False only for development.",
-    )
-
-    def get_httpx_ssl_context(self) -> ssl.SSLContext | bool | str:
-        """Build SSL context for httpx client.
-
-        Returns:
-            SSL context if certificates configured, True for default verification,
-            False if verification disabled, or path to CA bundle.
-        """
-        if not self.verify:
-            return False
-
-        if self.client_cert_path and self.client_key_path:
-            context = ssl.create_default_context()
-
-            if self.ca_cert_path:
-                context.load_verify_locations(cafile=str(self.ca_cert_path))
-
-            context.load_cert_chain(
-                certfile=str(self.client_cert_path),
-                keyfile=str(self.client_key_path),
-            )
-            return context
-
-        if self.ca_cert_path:
-            return str(self.ca_cert_path)
-
-        return True
-
-    def get_grpc_credentials(self) -> grpc.ChannelCredentials | None:  # type: ignore[no-any-unimported]
-        """Build gRPC channel credentials for secure connections.
-
-        Returns:
-            gRPC SSL credentials if certificates configured, None otherwise.
-        """
-        try:
-            import grpc
-        except ImportError:
-            return None
-
-        if not self.verify and not self.client_cert_path:
-            return None
-
-        root_certs: bytes | None = None
-        private_key: bytes | None = None
-        certificate_chain: bytes | None = None
-
-        if self.ca_cert_path:
-            root_certs = Path(self.ca_cert_path).read_bytes()
-
-        if self.client_cert_path and self.client_key_path:
-            private_key = Path(self.client_key_path).read_bytes()
-            certificate_chain = Path(self.client_cert_path).read_bytes()
-
-        return grpc.ssl_channel_credentials(
-            root_certificates=root_certs,
-            private_key=private_key,
-            certificate_chain=certificate_chain,
-        )
-
-
-class ClientAuthScheme(ABC, BaseModel):
-    """Base class for client-side authentication schemes.
-
-    Client auth schemes apply credentials to outgoing requests.
-
-    Attributes:
-        tls: Optional TLS/mTLS configuration for secure connections.
-    """
-
-    tls: TLSConfig | None = Field(
-        default=None,
-        description="TLS/mTLS configuration for secure connections",
-    )
-
-    @abstractmethod
-    async def apply_auth(
-        self, client: httpx.AsyncClient, headers: MutableMapping[str, str]
-    ) -> MutableMapping[str, str]:
-        """Apply authentication to request headers.
-
-        Args:
-            client: HTTP client for making auth requests.
-            headers: Current request headers.
-
-        Returns:
-            Updated headers with authentication applied.
-        """
-        ...
-
-
-@deprecated("Use ClientAuthScheme instead", category=FutureWarning)
-class AuthScheme(ClientAuthScheme):
-    """Deprecated: Use ClientAuthScheme instead."""
-
-
-class BearerTokenAuth(ClientAuthScheme):
-    """Bearer token authentication (Authorization: Bearer <token>).
-
-    Attributes:
-        token: Bearer token for authentication.
-    """
-
-    token: str = Field(description="Bearer token")
-
-    async def apply_auth(
-        self, client: httpx.AsyncClient, headers: MutableMapping[str, str]
-    ) -> MutableMapping[str, str]:
-        """Apply Bearer token to Authorization header.
-
-        Args:
-            client: HTTP client for making auth requests.
-            headers: Current request headers.
-
-        Returns:
-            Updated headers with Bearer token in Authorization header.
-        """
-        headers["Authorization"] = f"Bearer {self.token}"
-        return headers
-
-
-class HTTPBasicAuth(ClientAuthScheme):
-    """HTTP Basic authentication.
-
-    Attributes:
-        username: Username for Basic authentication.
-        password: Password for Basic authentication.
-    """
-
-    username: str = Field(description="Username")
-    password: str = Field(description="Password")
-
-    async def apply_auth(
-        self, client: httpx.AsyncClient, headers: MutableMapping[str, str]
-    ) -> MutableMapping[str, str]:
-        """Apply HTTP Basic authentication.
-
-        Args:
-            client: HTTP client for making auth requests.
-            headers: Current request headers.
-
-        Returns:
-            Updated headers with Basic auth in Authorization header.
-        """
-        credentials = f"{self.username}:{self.password}"
-        encoded = base64.b64encode(credentials.encode()).decode()
-        headers["Authorization"] = f"Basic {encoded}"
-        return headers
-
-
-class HTTPDigestAuth(ClientAuthScheme):
-    """HTTP Digest authentication.
-
-    Note: Uses httpx-auth library for digest implementation.
-
-    Attributes:
-        username: Username for Digest authentication.
-        password: Password for Digest authentication.
-    """
-
-    username: str = Field(description="Username")
-    password: str = Field(description="Password")
-
-    _configured_client_id: int | None = PrivateAttr(default=None)
-
-    async def apply_auth(
-        self, client: httpx.AsyncClient, headers: MutableMapping[str, str]
-    ) -> MutableMapping[str, str]:
-        """Digest auth is handled by httpx auth flow, not headers.
-
-        Args:
-            client: HTTP client for making auth requests.
-            headers: Current request headers.
-
-        Returns:
-            Unchanged headers (Digest auth handled by httpx auth flow).
-        """
-        return headers
-
-    def configure_client(self, client: httpx.AsyncClient) -> None:
-        """Configure client with Digest auth.
-
-        Idempotent: Only configures the client once. Subsequent calls on the same
-        client instance are no-ops to prevent overwriting auth configuration.
-
-        Args:
-            client: HTTP client to configure with Digest authentication.
-        """
-        client_id = id(client)
-        if self._configured_client_id == client_id:
-            return
-
-        client.auth = DigestAuth(self.username, self.password)
-        self._configured_client_id = client_id
-
-
-class APIKeyAuth(ClientAuthScheme):
-    """API Key authentication (header, query, or cookie).
-
-    Attributes:
-        api_key: API key value for authentication.
-        location: Where to send the API key (header, query, or cookie).
-        name: Parameter name for the API key (default: X-API-Key).
-    """
-
-    api_key: str = Field(description="API key value")
-    location: Literal["header", "query", "cookie"] = Field(
-        default="header", description="Where to send the API key"
-    )
-    name: str = Field(default="X-API-Key", description="Parameter name for the API key")
-
-    _configured_client_ids: set[int] = PrivateAttr(default_factory=set)
-
-    async def apply_auth(
-        self, client: httpx.AsyncClient, headers: MutableMapping[str, str]
-    ) -> MutableMapping[str, str]:
-        """Apply API key authentication.
-
-        Args:
-            client: HTTP client for making auth requests.
-            headers: Current request headers.
-
-        Returns:
-            Updated headers with API key (for header/cookie locations).
-        """
-        if self.location == "header":
-            headers[self.name] = self.api_key
-        elif self.location == "cookie":
-            headers["Cookie"] = f"{self.name}={self.api_key}"
-        return headers
-
-    def configure_client(self, client: httpx.AsyncClient) -> None:
-        """Configure client for query param API keys.
-
-        Idempotent: Only adds the request hook once per client instance.
-        Subsequent calls on the same client are no-ops to prevent hook accumulation.
-
-        Args:
-            client: HTTP client to configure with query param API key hook.
-        """
-        if self.location == "query":
-            client_id = id(client)
-            if client_id in self._configured_client_ids:
-                return
-
-            async def _add_api_key_param(request: httpx.Request) -> None:
-                url = httpx.URL(request.url)
-                request.url = url.copy_add_param(self.name, self.api_key)
-
-            client.event_hooks["request"].append(_add_api_key_param)
-            self._configured_client_ids.add(client_id)
-
-
-class OAuth2ClientCredentials(ClientAuthScheme):
-    """OAuth2 Client Credentials flow authentication.
-
-    Thread-safe implementation with asyncio.Lock to prevent concurrent token fetches
-    when multiple requests share the same auth instance.
-
-    Attributes:
-        token_url: OAuth2 token endpoint URL.
-        client_id: OAuth2 client identifier.
-        client_secret: OAuth2 client secret.
-        scopes: List of required OAuth2 scopes.
-    """
-
-    token_url: str = Field(description="OAuth2 token endpoint")
-    client_id: str = Field(description="OAuth2 client ID")
-    client_secret: str = Field(description="OAuth2 client secret")
-    scopes: list[str] = Field(
-        default_factory=list, description="Required OAuth2 scopes"
-    )
-
-    _access_token: str | None = PrivateAttr(default=None)
-    _token_expires_at: float | None = PrivateAttr(default=None)
-    _lock: asyncio.Lock = PrivateAttr(default_factory=asyncio.Lock)
-
-    async def apply_auth(
-        self, client: httpx.AsyncClient, headers: MutableMapping[str, str]
-    ) -> MutableMapping[str, str]:
-        """Apply OAuth2 access token to Authorization header.
-
-        Uses asyncio.Lock to ensure only one coroutine fetches tokens at a time,
-        preventing race conditions when multiple concurrent requests use the same
-        auth instance.
-
-        Args:
-            client: HTTP client for making token requests.
-            headers: Current request headers.
-
-        Returns:
-            Updated headers with OAuth2 access token in Authorization header.
-        """
-        if (
-            self._access_token is None
-            or self._token_expires_at is None
-            or time.time() >= self._token_expires_at
-        ):
-            async with self._lock:
-                if (
-                    self._access_token is None
-                    or self._token_expires_at is None
-                    or time.time() >= self._token_expires_at
-                ):
-                    await self._fetch_token(client)
-
-        if self._access_token:
-            headers["Authorization"] = f"Bearer {self._access_token}"
-
-        return headers
-
-    async def _fetch_token(self, client: httpx.AsyncClient) -> None:
-        """Fetch OAuth2 access token using client credentials flow.
-
-        Args:
-            client: HTTP client for making token request.
-
-        Raises:
-            httpx.HTTPStatusError: If token request fails.
-        """
-        data = {
-            "grant_type": "client_credentials",
-            "client_id": self.client_id,
-            "client_secret": self.client_secret,
-        }
-
-        if self.scopes:
-            data["scope"] = " ".join(self.scopes)
-
-        response = await client.post(self.token_url, data=data)
-        response.raise_for_status()
-
-        token_data = response.json()
-        self._access_token = token_data["access_token"]
-        expires_in = token_data.get("expires_in", 3600)
-        self._token_expires_at = time.time() + expires_in - 60
-
-
-class OAuth2AuthorizationCode(ClientAuthScheme):
-    """OAuth2 Authorization Code flow authentication.
-
-    Thread-safe implementation with asyncio.Lock to prevent concurrent token operations.
-
-    Note: Requires interactive authorization.
-
-    Attributes:
-        authorization_url: OAuth2 authorization endpoint URL.
-        token_url: OAuth2 token endpoint URL.
-        client_id: OAuth2 client identifier.
-        client_secret: OAuth2 client secret.
-        redirect_uri: OAuth2 redirect URI for callback.
-        scopes: List of required OAuth2 scopes.
-    """
-
-    authorization_url: str = Field(description="OAuth2 authorization endpoint")
-    token_url: str = Field(description="OAuth2 token endpoint")
-    client_id: str = Field(description="OAuth2 client ID")
-    client_secret: str = Field(description="OAuth2 client secret")
-    redirect_uri: str = Field(description="OAuth2 redirect URI")
-    scopes: list[str] = Field(
-        default_factory=list, description="Required OAuth2 scopes"
-    )
-
-    _access_token: str | None = PrivateAttr(default=None)
-    _refresh_token: str | None = PrivateAttr(default=None)
-    _token_expires_at: float | None = PrivateAttr(default=None)
-    _authorization_callback: Callable[[str], Awaitable[str]] | None = PrivateAttr(
-        default=None
-    )
-    _lock: asyncio.Lock = PrivateAttr(default_factory=asyncio.Lock)
-
-    def set_authorization_callback(
-        self, callback: Callable[[str], Awaitable[str]] | None
-    ) -> None:
-        """Set callback to handle authorization URL.
-
-        Args:
-            callback: Async function that receives authorization URL and returns auth code.
-        """
-        self._authorization_callback = callback
-
-    async def apply_auth(
-        self, client: httpx.AsyncClient, headers: MutableMapping[str, str]
-    ) -> MutableMapping[str, str]:
-        """Apply OAuth2 access token to Authorization header.
-
-        Uses asyncio.Lock to ensure only one coroutine handles token operations
-        (initial fetch or refresh) at a time.
-
-        Args:
-            client: HTTP client for making token requests.
-            headers: Current request headers.
-
-        Returns:
-            Updated headers with OAuth2 access token in Authorization header.
-
-        Raises:
-            ValueError: If authorization callback is not set.
-        """
-        if self._access_token is None:
-            if self._authorization_callback is None:
-                msg = "Authorization callback not set. Use set_authorization_callback()"
-                raise ValueError(msg)
-            async with self._lock:
-                if self._access_token is None:
-                    await self._fetch_initial_token(client)
-        elif self._token_expires_at and time.time() >= self._token_expires_at:
-            async with self._lock:
-                if self._token_expires_at and time.time() >= self._token_expires_at:
-                    await self._refresh_access_token(client)
-
-        if self._access_token:
-            headers["Authorization"] = f"Bearer {self._access_token}"
-
-        return headers
-
-    async def _fetch_initial_token(self, client: httpx.AsyncClient) -> None:
-        """Fetch initial access token using authorization code flow.
-
-        Args:
-            client: HTTP client for making token request.
-
-        Raises:
-            ValueError: If authorization callback is not set.
-            httpx.HTTPStatusError: If token request fails.
-        """
-        params = {
-            "response_type": "code",
-            "client_id": self.client_id,
-            "redirect_uri": self.redirect_uri,
-            "scope": " ".join(self.scopes),
-        }
-        auth_url = f"{self.authorization_url}?{urllib.parse.urlencode(params)}"
-
-        if self._authorization_callback is None:
-            msg = "Authorization callback not set"
-            raise ValueError(msg)
-        auth_code = await self._authorization_callback(auth_url)
-
-        data = {
-            "grant_type": "authorization_code",
-            "code": auth_code,
-            "client_id": self.client_id,
-            "client_secret": self.client_secret,
-            "redirect_uri": self.redirect_uri,
-        }
-
-        response = await client.post(self.token_url, data=data)
-        response.raise_for_status()
-
-        token_data = response.json()
-        self._access_token = token_data["access_token"]
-        self._refresh_token = token_data.get("refresh_token")
-
-        expires_in = token_data.get("expires_in", 3600)
-        self._token_expires_at = time.time() + expires_in - 60
-
-    async def _refresh_access_token(self, client: httpx.AsyncClient) -> None:
-        """Refresh the access token using refresh token.
-
-        Args:
-            client: HTTP client for making token request.
-
-        Raises:
-            httpx.HTTPStatusError: If token refresh request fails.
-        """
-        if not self._refresh_token:
-            await self._fetch_initial_token(client)
-            return
-
-        data = {
-            "grant_type": "refresh_token",
-            "refresh_token": self._refresh_token,
-            "client_id": self.client_id,
-            "client_secret": self.client_secret,
-        }
-
-        response = await client.post(self.token_url, data=data)
-        response.raise_for_status()
-
-        token_data = response.json()
-        self._access_token = token_data["access_token"]
-        if "refresh_token" in token_data:
-            self._refresh_token = token_data["refresh_token"]
-
-        expires_in = token_data.get("expires_in", 3600)
-        self._token_expires_at = time.time() + expires_in - 60

lib/crewai/src/crewai/a2a/auth/schemas.py

@@ -1,71 +1,392 @@
-"""Deprecated: Authentication schemes for A2A protocol agents.
+"""Authentication schemes for A2A protocol agents.
 
-This module is deprecated. Import from crewai.a2a.auth instead:
-- crewai.a2a.auth.ClientAuthScheme (replaces AuthScheme)
-- crewai.a2a.auth.BearerTokenAuth
-- crewai.a2a.auth.HTTPBasicAuth
-- crewai.a2a.auth.HTTPDigestAuth
-- crewai.a2a.auth.APIKeyAuth
-- crewai.a2a.auth.OAuth2ClientCredentials
-- crewai.a2a.auth.OAuth2AuthorizationCode
+Supported authentication methods:
+- Bearer tokens
+- OAuth2 (Client Credentials, Authorization Code)
+- API Keys (header, query, cookie)
+- HTTP Basic authentication
+- HTTP Digest authentication
 """
 
 from __future__ import annotations
 
-from typing_extensions import deprecated
+from abc import ABC, abstractmethod
+import base64
+from collections.abc import Awaitable, Callable, MutableMapping
+import time
+from typing import Literal
+import urllib.parse
 
-from crewai.a2a.auth.client_schemes import (
-    APIKeyAuth as _APIKeyAuth,
-    BearerTokenAuth as _BearerTokenAuth,
-    ClientAuthScheme as _ClientAuthScheme,
-    HTTPBasicAuth as _HTTPBasicAuth,
-    HTTPDigestAuth as _HTTPDigestAuth,
-    OAuth2AuthorizationCode as _OAuth2AuthorizationCode,
-    OAuth2ClientCredentials as _OAuth2ClientCredentials,
-)
+import httpx
+from httpx import DigestAuth
+from pydantic import BaseModel, Field, PrivateAttr
 
 
-@deprecated("Use ClientAuthScheme from crewai.a2a.auth instead", category=FutureWarning)
-class AuthScheme(_ClientAuthScheme):
-    """Deprecated: Use ClientAuthScheme from crewai.a2a.auth instead."""
+class AuthScheme(ABC, BaseModel):
+    """Base class for authentication schemes."""
+
+    @abstractmethod
+    async def apply_auth(
+        self, client: httpx.AsyncClient, headers: MutableMapping[str, str]
+    ) -> MutableMapping[str, str]:
+        """Apply authentication to request headers.
+
+        Args:
+            client: HTTP client for making auth requests.
+            headers: Current request headers.
+
+        Returns:
+            Updated headers with authentication applied.
+        """
+        ...
 
 
-@deprecated("Import from crewai.a2a.auth instead", category=FutureWarning)
-class BearerTokenAuth(_BearerTokenAuth):
-    """Deprecated: Import from crewai.a2a.auth instead."""
+class BearerTokenAuth(AuthScheme):
+    """Bearer token authentication (Authorization: Bearer <token>).
+
+    Attributes:
+        token: Bearer token for authentication.
+    """
+
+    token: str = Field(description="Bearer token")
+
+    async def apply_auth(
+        self, client: httpx.AsyncClient, headers: MutableMapping[str, str]
+    ) -> MutableMapping[str, str]:
+        """Apply Bearer token to Authorization header.
+
+        Args:
+            client: HTTP client for making auth requests.
+            headers: Current request headers.
+
+        Returns:
+            Updated headers with Bearer token in Authorization header.
+        """
+        headers["Authorization"] = f"Bearer {self.token}"
+        return headers
 
 
-@deprecated("Import from crewai.a2a.auth instead", category=FutureWarning)
-class HTTPBasicAuth(_HTTPBasicAuth):
-    """Deprecated: Import from crewai.a2a.auth instead."""
+class HTTPBasicAuth(AuthScheme):
+    """HTTP Basic authentication.
+
+    Attributes:
+        username: Username for Basic authentication.
+        password: Password for Basic authentication.
+    """
+
+    username: str = Field(description="Username")
+    password: str = Field(description="Password")
+
+    async def apply_auth(
+        self, client: httpx.AsyncClient, headers: MutableMapping[str, str]
+    ) -> MutableMapping[str, str]:
+        """Apply HTTP Basic authentication.
+
+        Args:
+            client: HTTP client for making auth requests.
+            headers: Current request headers.
+
+        Returns:
+            Updated headers with Basic auth in Authorization header.
+        """
+        credentials = f"{self.username}:{self.password}"
+        encoded = base64.b64encode(credentials.encode()).decode()
+        headers["Authorization"] = f"Basic {encoded}"
+        return headers
 
 
-@deprecated("Import from crewai.a2a.auth instead", category=FutureWarning)
-class HTTPDigestAuth(_HTTPDigestAuth):
-    """Deprecated: Import from crewai.a2a.auth instead."""
+class HTTPDigestAuth(AuthScheme):
+    """HTTP Digest authentication.
+
+    Note: Uses httpx-auth library for digest implementation.
+
+    Attributes:
+        username: Username for Digest authentication.
+        password: Password for Digest authentication.
+    """
+
+    username: str = Field(description="Username")
+    password: str = Field(description="Password")
+
+    async def apply_auth(
+        self, client: httpx.AsyncClient, headers: MutableMapping[str, str]
+    ) -> MutableMapping[str, str]:
+        """Digest auth is handled by httpx auth flow, not headers.
+
+        Args:
+            client: HTTP client for making auth requests.
+            headers: Current request headers.
+
+        Returns:
+            Unchanged headers (Digest auth handled by httpx auth flow).
+        """
+        return headers
+
+    def configure_client(self, client: httpx.AsyncClient) -> None:
+        """Configure client with Digest auth.
+
+        Args:
+            client: HTTP client to configure with Digest authentication.
+        """
+        client.auth = DigestAuth(self.username, self.password)
 
 
-@deprecated("Import from crewai.a2a.auth instead", category=FutureWarning)
-class APIKeyAuth(_APIKeyAuth):
-    """Deprecated: Import from crewai.a2a.auth instead."""
+class APIKeyAuth(AuthScheme):
+    """API Key authentication (header, query, or cookie).
+
+    Attributes:
+        api_key: API key value for authentication.
+        location: Where to send the API key (header, query, or cookie).
+        name: Parameter name for the API key (default: X-API-Key).
+    """
+
+    api_key: str = Field(description="API key value")
+    location: Literal["header", "query", "cookie"] = Field(
+        default="header", description="Where to send the API key"
+    )
+    name: str = Field(default="X-API-Key", description="Parameter name for the API key")
+
+    async def apply_auth(
+        self, client: httpx.AsyncClient, headers: MutableMapping[str, str]
+    ) -> MutableMapping[str, str]:
+        """Apply API key authentication.
+
+        Args:
+            client: HTTP client for making auth requests.
+            headers: Current request headers.
+
+        Returns:
+            Updated headers with API key (for header/cookie locations).
+        """
+        if self.location == "header":
+            headers[self.name] = self.api_key
+        elif self.location == "cookie":
+            headers["Cookie"] = f"{self.name}={self.api_key}"
+        return headers
+
+    def configure_client(self, client: httpx.AsyncClient) -> None:
+        """Configure client for query param API keys.
+
+        Args:
+            client: HTTP client to configure with query param API key hook.
+        """
+        if self.location == "query":
+
+            async def _add_api_key_param(request: httpx.Request) -> None:
+                url = httpx.URL(request.url)
+                request.url = url.copy_add_param(self.name, self.api_key)
+
+            client.event_hooks["request"].append(_add_api_key_param)
 
 
-@deprecated("Import from crewai.a2a.auth instead", category=FutureWarning)
-class OAuth2ClientCredentials(_OAuth2ClientCredentials):
-    """Deprecated: Import from crewai.a2a.auth instead."""
+class OAuth2ClientCredentials(AuthScheme):
+    """OAuth2 Client Credentials flow authentication.
+
+    Attributes:
+        token_url: OAuth2 token endpoint URL.
+        client_id: OAuth2 client identifier.
+        client_secret: OAuth2 client secret.
+        scopes: List of required OAuth2 scopes.
+    """
+
+    token_url: str = Field(description="OAuth2 token endpoint")
+    client_id: str = Field(description="OAuth2 client ID")
+    client_secret: str = Field(description="OAuth2 client secret")
+    scopes: list[str] = Field(
+        default_factory=list, description="Required OAuth2 scopes"
+    )
+
+    _access_token: str | None = PrivateAttr(default=None)
+    _token_expires_at: float | None = PrivateAttr(default=None)
+
+    async def apply_auth(
+        self, client: httpx.AsyncClient, headers: MutableMapping[str, str]
+    ) -> MutableMapping[str, str]:
+        """Apply OAuth2 access token to Authorization header.
+
+        Args:
+            client: HTTP client for making token requests.
+            headers: Current request headers.
+
+        Returns:
+            Updated headers with OAuth2 access token in Authorization header.
+        """
+        if (
+            self._access_token is None
+            or self._token_expires_at is None
+            or time.time() >= self._token_expires_at
+        ):
+            await self._fetch_token(client)
+
+        if self._access_token:
+            headers["Authorization"] = f"Bearer {self._access_token}"
+
+        return headers
+
+    async def _fetch_token(self, client: httpx.AsyncClient) -> None:
+        """Fetch OAuth2 access token using client credentials flow.
+
+        Args:
+            client: HTTP client for making token request.
+
+        Raises:
+            httpx.HTTPStatusError: If token request fails.
+        """
+        data = {
+            "grant_type": "client_credentials",
+            "client_id": self.client_id,
+            "client_secret": self.client_secret,
+        }
+
+        if self.scopes:
+            data["scope"] = " ".join(self.scopes)
+
+        response = await client.post(self.token_url, data=data)
+        response.raise_for_status()
+
+        token_data = response.json()
+        self._access_token = token_data["access_token"]
+        expires_in = token_data.get("expires_in", 3600)
+        self._token_expires_at = time.time() + expires_in - 60
 
 
-@deprecated("Import from crewai.a2a.auth instead", category=FutureWarning)
-class OAuth2AuthorizationCode(_OAuth2AuthorizationCode):
-    """Deprecated: Import from crewai.a2a.auth instead."""
+class OAuth2AuthorizationCode(AuthScheme):
+    """OAuth2 Authorization Code flow authentication.
 
+    Note: Requires interactive authorization.
 
-__all__ = [
-    "APIKeyAuth",
-    "AuthScheme",
-    "BearerTokenAuth",
-    "HTTPBasicAuth",
-    "HTTPDigestAuth",
-    "OAuth2AuthorizationCode",
-    "OAuth2ClientCredentials",
-]
+    Attributes:
+        authorization_url: OAuth2 authorization endpoint URL.
+        token_url: OAuth2 token endpoint URL.
+        client_id: OAuth2 client identifier.
+        client_secret: OAuth2 client secret.
+        redirect_uri: OAuth2 redirect URI for callback.
+        scopes: List of required OAuth2 scopes.
+    """
+
+    authorization_url: str = Field(description="OAuth2 authorization endpoint")
+    token_url: str = Field(description="OAuth2 token endpoint")
+    client_id: str = Field(description="OAuth2 client ID")
+    client_secret: str = Field(description="OAuth2 client secret")
+    redirect_uri: str = Field(description="OAuth2 redirect URI")
+    scopes: list[str] = Field(
+        default_factory=list, description="Required OAuth2 scopes"
+    )
+
+    _access_token: str | None = PrivateAttr(default=None)
+    _refresh_token: str | None = PrivateAttr(default=None)
+    _token_expires_at: float | None = PrivateAttr(default=None)
+    _authorization_callback: Callable[[str], Awaitable[str]] | None = PrivateAttr(
+        default=None
+    )
+
+    def set_authorization_callback(
+        self, callback: Callable[[str], Awaitable[str]] | None
+    ) -> None:
+        """Set callback to handle authorization URL.
+
+        Args:
+            callback: Async function that receives authorization URL and returns auth code.
+        """
+        self._authorization_callback = callback
+
+    async def apply_auth(
+        self, client: httpx.AsyncClient, headers: MutableMapping[str, str]
+    ) -> MutableMapping[str, str]:
+        """Apply OAuth2 access token to Authorization header.
+
+        Args:
+            client: HTTP client for making token requests.
+            headers: Current request headers.
+
+        Returns:
+            Updated headers with OAuth2 access token in Authorization header.
+
+        Raises:
+            ValueError: If authorization callback is not set.
+        """
+
+        if self._access_token is None:
+            if self._authorization_callback is None:
+                msg = "Authorization callback not set. Use set_authorization_callback()"
+                raise ValueError(msg)
+            await self._fetch_initial_token(client)
+        elif self._token_expires_at and time.time() >= self._token_expires_at:
+            await self._refresh_access_token(client)
+
+        if self._access_token:
+            headers["Authorization"] = f"Bearer {self._access_token}"
+
+        return headers
+
+    async def _fetch_initial_token(self, client: httpx.AsyncClient) -> None:
+        """Fetch initial access token using authorization code flow.
+
+        Args:
+            client: HTTP client for making token request.
+
+        Raises:
+            ValueError: If authorization callback is not set.
+            httpx.HTTPStatusError: If token request fails.
+        """
+        params = {
+            "response_type": "code",
+            "client_id": self.client_id,
+            "redirect_uri": self.redirect_uri,
+            "scope": " ".join(self.scopes),
+        }
+        auth_url = f"{self.authorization_url}?{urllib.parse.urlencode(params)}"
+
+        if self._authorization_callback is None:
+            msg = "Authorization callback not set"
+            raise ValueError(msg)
+        auth_code = await self._authorization_callback(auth_url)
+
+        data = {
+            "grant_type": "authorization_code",
+            "code": auth_code,
+            "client_id": self.client_id,
+            "client_secret": self.client_secret,
+            "redirect_uri": self.redirect_uri,
+        }
+
+        response = await client.post(self.token_url, data=data)
+        response.raise_for_status()
+
+        token_data = response.json()
+        self._access_token = token_data["access_token"]
+        self._refresh_token = token_data.get("refresh_token")
+
+        expires_in = token_data.get("expires_in", 3600)
+        self._token_expires_at = time.time() + expires_in - 60
+
+    async def _refresh_access_token(self, client: httpx.AsyncClient) -> None:
+        """Refresh the access token using refresh token.
+
+        Args:
+            client: HTTP client for making token request.
+
+        Raises:
+            httpx.HTTPStatusError: If token refresh request fails.
+        """
+        if not self._refresh_token:
+            await self._fetch_initial_token(client)
+            return
+
+        data = {
+            "grant_type": "refresh_token",
+            "refresh_token": self._refresh_token,
+            "client_id": self.client_id,
+            "client_secret": self.client_secret,
+        }
+
+        response = await client.post(self.token_url, data=data)
+        response.raise_for_status()
+
+        token_data = response.json()
+        self._access_token = token_data["access_token"]
+        if "refresh_token" in token_data:
+            self._refresh_token = token_data["refresh_token"]
+
+        expires_in = token_data.get("expires_in", 3600)
+        self._token_expires_at = time.time() + expires_in - 60

lib/crewai/src/crewai/a2a/auth/server_schemes.py

@@ -1,739 +0,0 @@
-"""Server-side authentication schemes for A2A protocol.
-
-These schemes validate incoming requests to A2A server endpoints.
-
-Supported authentication methods:
-- Simple token validation with static bearer tokens
-- OpenID Connect with JWT validation using JWKS
-- OAuth2 with JWT validation or token introspection
-"""
-
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from dataclasses import dataclass
-import logging
-import os
-from typing import TYPE_CHECKING, Annotated, Any, ClassVar, Literal
-
-import jwt
-from jwt import PyJWKClient
-from pydantic import (
-    BaseModel,
-    BeforeValidator,
-    ConfigDict,
-    Field,
-    HttpUrl,
-    PrivateAttr,
-    SecretStr,
-    model_validator,
-)
-from typing_extensions import Self
-
-
-if TYPE_CHECKING:
-    from a2a.types import OAuth2SecurityScheme
-
-
-logger = logging.getLogger(__name__)
-
-
-try:
-    from fastapi import HTTPException, status as http_status
-
-    HTTP_401_UNAUTHORIZED = http_status.HTTP_401_UNAUTHORIZED
-    HTTP_500_INTERNAL_SERVER_ERROR = http_status.HTTP_500_INTERNAL_SERVER_ERROR
-    HTTP_503_SERVICE_UNAVAILABLE = http_status.HTTP_503_SERVICE_UNAVAILABLE
-except ImportError:
-
-    class HTTPException(Exception):  # type: ignore[no-redef]  # noqa: N818
-        """Fallback HTTPException when FastAPI is not installed."""
-
-        def __init__(
-            self,
-            status_code: int,
-            detail: str | None = None,
-            headers: dict[str, str] | None = None,
-        ) -> None:
-            self.status_code = status_code
-            self.detail = detail
-            self.headers = headers
-            super().__init__(detail)
-
-    HTTP_401_UNAUTHORIZED = 401
-    HTTP_500_INTERNAL_SERVER_ERROR = 500
-    HTTP_503_SERVICE_UNAVAILABLE = 503
-
-
-def _coerce_secret_str(v: str | SecretStr | None) -> SecretStr | None:
-    """Coerce string to SecretStr."""
-    if v is None or isinstance(v, SecretStr):
-        return v
-    return SecretStr(v)
-
-
-CoercedSecretStr = Annotated[SecretStr, BeforeValidator(_coerce_secret_str)]
-
-JWTAlgorithm = Literal[
-    "RS256",
-    "RS384",
-    "RS512",
-    "ES256",
-    "ES384",
-    "ES512",
-    "PS256",
-    "PS384",
-    "PS512",
-]
-
-
-@dataclass
-class AuthenticatedUser:
-    """Result of successful authentication.
-
-    Attributes:
-        token: The original token that was validated.
-        scheme: Name of the authentication scheme used.
-        claims: JWT claims from OIDC or OAuth2 authentication.
-    """
-
-    token: str
-    scheme: str
-    claims: dict[str, Any] | None = None
-
-
-class ServerAuthScheme(ABC, BaseModel):
-    """Base class for server-side authentication schemes.
-
-    Each scheme validates incoming requests and returns an AuthenticatedUser
-    on success, or raises HTTPException on failure.
-    """
-
-    model_config: ClassVar[ConfigDict] = ConfigDict(extra="forbid")
-
-    @abstractmethod
-    async def authenticate(self, token: str) -> AuthenticatedUser:
-        """Authenticate the provided token.
-
-        Args:
-            token: The bearer token to authenticate.
-
-        Returns:
-            AuthenticatedUser on successful authentication.
-
-        Raises:
-            HTTPException: If authentication fails.
-        """
-        ...
-
-
-class SimpleTokenAuth(ServerAuthScheme):
-    """Simple bearer token authentication.
-
-    Validates tokens against a configured static token or AUTH_TOKEN env var.
-
-    Attributes:
-        token: Expected token value. Falls back to AUTH_TOKEN env var if not set.
-    """
-
-    token: CoercedSecretStr | None = Field(
-        default=None,
-        description="Expected token. Falls back to AUTH_TOKEN env var.",
-    )
-
-    def _get_expected_token(self) -> str | None:
-        """Get the expected token value."""
-        if self.token:
-            return self.token.get_secret_value()
-        return os.environ.get("AUTH_TOKEN")
-
-    async def authenticate(self, token: str) -> AuthenticatedUser:
-        """Authenticate using simple token comparison.
-
-        Args:
-            token: The bearer token to authenticate.
-
-        Returns:
-            AuthenticatedUser on successful authentication.
-
-        Raises:
-            HTTPException: If authentication fails.
-        """
-        expected = self._get_expected_token()
-
-        if expected is None:
-            logger.warning(
-                "Simple token authentication failed",
-                extra={"reason": "no_token_configured"},
-            )
-            raise HTTPException(
-                status_code=HTTP_401_UNAUTHORIZED,
-                detail="Authentication not configured",
-            )
-
-        if token != expected:
-            raise HTTPException(
-                status_code=HTTP_401_UNAUTHORIZED,
-                detail="Invalid or missing authentication credentials",
-            )
-
-        return AuthenticatedUser(
-            token=token,
-            scheme="simple_token",
-        )
-
-
-class OIDCAuth(ServerAuthScheme):
-    """OpenID Connect authentication.
-
-    Validates JWTs using JWKS with caching support via PyJWT.
-
-    Attributes:
-        issuer: The OpenID Connect issuer URL.
-        audience: The expected audience claim.
-        jwks_url: Optional explicit JWKS URL. Derived from issuer if not set.
-        algorithms: List of allowed signing algorithms.
-        required_claims: List of claims that must be present in the token.
-        jwks_cache_ttl: TTL for JWKS cache in seconds.
-        clock_skew_seconds: Allowed clock skew for token validation.
-    """
-
-    issuer: HttpUrl = Field(
-        description="OpenID Connect issuer URL (e.g., https://auth.example.com)"
-    )
-    audience: str = Field(description="Expected audience claim (e.g., api://my-agent)")
-    jwks_url: HttpUrl | None = Field(
-        default=None,
-        description="Explicit JWKS URL. Derived from issuer if not set.",
-    )
-    algorithms: list[str] = Field(
-        default_factory=lambda: ["RS256"],
-        description="List of allowed signing algorithms (RS256, ES256, etc.)",
-    )
-    required_claims: list[str] = Field(
-        default_factory=lambda: ["exp", "iat", "iss", "aud", "sub"],
-        description="List of claims that must be present in the token",
-    )
-    jwks_cache_ttl: int = Field(
-        default=3600,
-        description="TTL for JWKS cache in seconds",
-        ge=60,
-    )
-    clock_skew_seconds: float = Field(
-        default=30.0,
-        description="Allowed clock skew for token validation",
-        ge=0.0,
-    )
-
-    _jwk_client: PyJWKClient | None = PrivateAttr(default=None)
-
-    @model_validator(mode="after")
-    def _init_jwk_client(self) -> Self:
-        """Initialize the JWK client after model creation."""
-        jwks_url = (
-            str(self.jwks_url)
-            if self.jwks_url
-            else f"{str(self.issuer).rstrip('/')}/.well-known/jwks.json"
-        )
-        self._jwk_client = PyJWKClient(jwks_url, lifespan=self.jwks_cache_ttl)
-        return self
-
-    async def authenticate(self, token: str) -> AuthenticatedUser:
-        """Authenticate using OIDC JWT validation.
-
-        Args:
-            token: The JWT to authenticate.
-
-        Returns:
-            AuthenticatedUser on successful authentication.
-
-        Raises:
-            HTTPException: If authentication fails.
-        """
-        if self._jwk_client is None:
-            raise HTTPException(
-                status_code=HTTP_500_INTERNAL_SERVER_ERROR,
-                detail="OIDC not initialized",
-            )
-
-        try:
-            signing_key = self._jwk_client.get_signing_key_from_jwt(token)
-
-            claims = jwt.decode(
-                token,
-                signing_key.key,
-                algorithms=self.algorithms,
-                audience=self.audience,
-                issuer=str(self.issuer).rstrip("/"),
-                leeway=self.clock_skew_seconds,
-                options={
-                    "require": self.required_claims,
-                },
-            )
-
-            return AuthenticatedUser(
-                token=token,
-                scheme="oidc",
-                claims=claims,
-            )
-
-        except jwt.ExpiredSignatureError:
-            logger.debug(
-                "OIDC authentication failed",
-                extra={"reason": "token_expired", "scheme": "oidc"},
-            )
-            raise HTTPException(
-                status_code=HTTP_401_UNAUTHORIZED,
-                detail="Token has expired",
-            ) from None
-        except jwt.InvalidAudienceError:
-            logger.debug(
-                "OIDC authentication failed",
-                extra={"reason": "invalid_audience", "scheme": "oidc"},
-            )
-            raise HTTPException(
-                status_code=HTTP_401_UNAUTHORIZED,
-                detail="Invalid token audience",
-            ) from None
-        except jwt.InvalidIssuerError:
-            logger.debug(
-                "OIDC authentication failed",
-                extra={"reason": "invalid_issuer", "scheme": "oidc"},
-            )
-            raise HTTPException(
-                status_code=HTTP_401_UNAUTHORIZED,
-                detail="Invalid token issuer",
-            ) from None
-        except jwt.MissingRequiredClaimError as e:
-            logger.debug(
-                "OIDC authentication failed",
-                extra={"reason": "missing_claim", "claim": e.claim, "scheme": "oidc"},
-            )
-            raise HTTPException(
-                status_code=HTTP_401_UNAUTHORIZED,
-                detail=f"Missing required claim: {e.claim}",
-            ) from None
-        except jwt.PyJWKClientError as e:
-            logger.error(
-                "OIDC authentication failed",
-                extra={
-                    "reason": "jwks_client_error",
-                    "error": str(e),
-                    "scheme": "oidc",
-                },
-            )
-            raise HTTPException(
-                status_code=HTTP_503_SERVICE_UNAVAILABLE,
-                detail="Unable to fetch signing keys",
-            ) from None
-        except jwt.InvalidTokenError as e:
-            logger.debug(
-                "OIDC authentication failed",
-                extra={"reason": "invalid_token", "error": str(e), "scheme": "oidc"},
-            )
-            raise HTTPException(
-                status_code=HTTP_401_UNAUTHORIZED,
-                detail="Invalid or missing authentication credentials",
-            ) from None
-
-
-class OAuth2ServerAuth(ServerAuthScheme):
-    """OAuth2 authentication for A2A server.
-
-    Declares OAuth2 security scheme in AgentCard and validates tokens using
-    either JWKS for JWT tokens or token introspection for opaque tokens.
-
-    This is distinct from OIDCAuth in that it declares an explicit OAuth2SecurityScheme
-    with flows, rather than an OpenIdConnectSecurityScheme with discovery URL.
-
-    Attributes:
-        token_url: OAuth2 token endpoint URL for client_credentials flow.
-        authorization_url: OAuth2 authorization endpoint for authorization_code flow.
-        refresh_url: Optional refresh token endpoint URL.
-        scopes: Available OAuth2 scopes with descriptions.
-        jwks_url: JWKS URL for JWT validation. Required if not using introspection.
-        introspection_url: Token introspection endpoint (RFC 7662). Alternative to JWKS.
-        introspection_client_id: Client ID for introspection endpoint authentication.
-        introspection_client_secret: Client secret for introspection endpoint.
-        audience: Expected audience claim for JWT validation.
-        issuer: Expected issuer claim for JWT validation.
-        algorithms: Allowed JWT signing algorithms.
-        required_claims: Claims that must be present in the token.
-        jwks_cache_ttl: TTL for JWKS cache in seconds.
-        clock_skew_seconds: Allowed clock skew for token validation.
-    """
-
-    token_url: HttpUrl = Field(
-        description="OAuth2 token endpoint URL",
-    )
-    authorization_url: HttpUrl | None = Field(
-        default=None,
-        description="OAuth2 authorization endpoint URL for authorization_code flow",
-    )
-    refresh_url: HttpUrl | None = Field(
-        default=None,
-        description="OAuth2 refresh token endpoint URL",
-    )
-    scopes: dict[str, str] = Field(
-        default_factory=dict,
-        description="Available OAuth2 scopes with descriptions",
-    )
-    jwks_url: HttpUrl | None = Field(
-        default=None,
-        description="JWKS URL for JWT validation. Required if not using introspection.",
-    )
-    introspection_url: HttpUrl | None = Field(
-        default=None,
-        description="Token introspection endpoint (RFC 7662). Alternative to JWKS.",
-    )
-    introspection_client_id: str | None = Field(
-        default=None,
-        description="Client ID for introspection endpoint authentication",
-    )
-    introspection_client_secret: CoercedSecretStr | None = Field(
-        default=None,
-        description="Client secret for introspection endpoint authentication",
-    )
-    audience: str | None = Field(
-        default=None,
-        description="Expected audience claim for JWT validation",
-    )
-    issuer: str | None = Field(
-        default=None,
-        description="Expected issuer claim for JWT validation",
-    )
-    algorithms: list[str] = Field(
-        default_factory=lambda: ["RS256"],
-        description="Allowed JWT signing algorithms",
-    )
-    required_claims: list[str] = Field(
-        default_factory=lambda: ["exp", "iat"],
-        description="Claims that must be present in the token",
-    )
-    jwks_cache_ttl: int = Field(
-        default=3600,
-        description="TTL for JWKS cache in seconds",
-        ge=60,
-    )
-    clock_skew_seconds: float = Field(
-        default=30.0,
-        description="Allowed clock skew for token validation",
-        ge=0.0,
-    )
-
-    _jwk_client: PyJWKClient | None = PrivateAttr(default=None)
-
-    @model_validator(mode="after")
-    def _validate_and_init(self) -> Self:
-        """Validate configuration and initialize JWKS client if needed."""
-        if not self.jwks_url and not self.introspection_url:
-            raise ValueError(
-                "Either jwks_url or introspection_url must be provided for token validation"
-            )
-
-        if self.introspection_url:
-            if not self.introspection_client_id or not self.introspection_client_secret:
-                raise ValueError(
-                    "introspection_client_id and introspection_client_secret are required "
-                    "when using token introspection"
-                )
-
-        if self.jwks_url:
-            self._jwk_client = PyJWKClient(
-                str(self.jwks_url), lifespan=self.jwks_cache_ttl
-            )
-
-        return self
-
-    async def authenticate(self, token: str) -> AuthenticatedUser:
-        """Authenticate using OAuth2 token validation.
-
-        Uses JWKS validation if jwks_url is configured, otherwise falls back
-        to token introspection.
-
-        Args:
-            token: The OAuth2 access token to authenticate.
-
-        Returns:
-            AuthenticatedUser on successful authentication.
-
-        Raises:
-            HTTPException: If authentication fails.
-        """
-        if self._jwk_client:
-            return await self._authenticate_jwt(token)
-        return await self._authenticate_introspection(token)
-
-    async def _authenticate_jwt(self, token: str) -> AuthenticatedUser:
-        """Authenticate using JWKS JWT validation."""
-        if self._jwk_client is None:
-            raise HTTPException(
-                status_code=HTTP_500_INTERNAL_SERVER_ERROR,
-                detail="OAuth2 JWKS not initialized",
-            )
-
-        try:
-            signing_key = self._jwk_client.get_signing_key_from_jwt(token)
-
-            decode_options: dict[str, Any] = {
-                "require": self.required_claims,
-            }
-
-            claims = jwt.decode(
-                token,
-                signing_key.key,
-                algorithms=self.algorithms,
-                audience=self.audience,
-                issuer=self.issuer,
-                leeway=self.clock_skew_seconds,
-                options=decode_options,
-            )
-
-            return AuthenticatedUser(
-                token=token,
-                scheme="oauth2",
-                claims=claims,
-            )
-
-        except jwt.ExpiredSignatureError:
-            logger.debug(
-                "OAuth2 authentication failed",
-                extra={"reason": "token_expired", "scheme": "oauth2"},
-            )
-            raise HTTPException(
-                status_code=HTTP_401_UNAUTHORIZED,
-                detail="Token has expired",
-            ) from None
-        except jwt.InvalidAudienceError:
-            logger.debug(
-                "OAuth2 authentication failed",
-                extra={"reason": "invalid_audience", "scheme": "oauth2"},
-            )
-            raise HTTPException(
-                status_code=HTTP_401_UNAUTHORIZED,
-                detail="Invalid token audience",
-            ) from None
-        except jwt.InvalidIssuerError:
-            logger.debug(
-                "OAuth2 authentication failed",
-                extra={"reason": "invalid_issuer", "scheme": "oauth2"},
-            )
-            raise HTTPException(
-                status_code=HTTP_401_UNAUTHORIZED,
-                detail="Invalid token issuer",
-            ) from None
-        except jwt.MissingRequiredClaimError as e:
-            logger.debug(
-                "OAuth2 authentication failed",
-                extra={"reason": "missing_claim", "claim": e.claim, "scheme": "oauth2"},
-            )
-            raise HTTPException(
-                status_code=HTTP_401_UNAUTHORIZED,
-                detail=f"Missing required claim: {e.claim}",
-            ) from None
-        except jwt.PyJWKClientError as e:
-            logger.error(
-                "OAuth2 authentication failed",
-                extra={
-                    "reason": "jwks_client_error",
-                    "error": str(e),
-                    "scheme": "oauth2",
-                },
-            )
-            raise HTTPException(
-                status_code=HTTP_503_SERVICE_UNAVAILABLE,
-                detail="Unable to fetch signing keys",
-            ) from None
-        except jwt.InvalidTokenError as e:
-            logger.debug(
-                "OAuth2 authentication failed",
-                extra={"reason": "invalid_token", "error": str(e), "scheme": "oauth2"},
-            )
-            raise HTTPException(
-                status_code=HTTP_401_UNAUTHORIZED,
-                detail="Invalid or missing authentication credentials",
-            ) from None
-
-    async def _authenticate_introspection(self, token: str) -> AuthenticatedUser:
-        """Authenticate using OAuth2 token introspection (RFC 7662)."""
-        import httpx
-
-        if not self.introspection_url:
-            raise HTTPException(
-                status_code=HTTP_500_INTERNAL_SERVER_ERROR,
-                detail="OAuth2 introspection not configured",
-            )
-
-        try:
-            async with httpx.AsyncClient() as client:
-                response = await client.post(
-                    str(self.introspection_url),
-                    data={"token": token},
-                    auth=(
-                        self.introspection_client_id or "",
-                        self.introspection_client_secret.get_secret_value()
-                        if self.introspection_client_secret
-                        else "",
-                    ),
-                )
-                response.raise_for_status()
-                introspection_result = response.json()
-
-        except httpx.HTTPStatusError as e:
-            logger.error(
-                "OAuth2 introspection failed",
-                extra={"reason": "http_error", "status_code": e.response.status_code},
-            )
-            raise HTTPException(
-                status_code=HTTP_503_SERVICE_UNAVAILABLE,
-                detail="Token introspection service unavailable",
-            ) from None
-        except Exception as e:
-            logger.error(
-                "OAuth2 introspection failed",
-                extra={"reason": "unexpected_error", "error": str(e)},
-            )
-            raise HTTPException(
-                status_code=HTTP_503_SERVICE_UNAVAILABLE,
-                detail="Token introspection failed",
-            ) from None
-
-        if not introspection_result.get("active", False):
-            logger.debug(
-                "OAuth2 authentication failed",
-                extra={"reason": "token_not_active", "scheme": "oauth2"},
-            )
-            raise HTTPException(
-                status_code=HTTP_401_UNAUTHORIZED,
-                detail="Token is not active",
-            )
-
-        return AuthenticatedUser(
-            token=token,
-            scheme="oauth2",
-            claims=introspection_result,
-        )
-
-    def to_security_scheme(self) -> OAuth2SecurityScheme:
-        """Generate OAuth2SecurityScheme for AgentCard declaration.
-
-        Creates an OAuth2SecurityScheme with appropriate flows based on
-        the configured URLs. Includes client_credentials flow if token_url
-        is set, and authorization_code flow if authorization_url is set.
-
-        Returns:
-            OAuth2SecurityScheme suitable for use in AgentCard security_schemes.
-        """
-        from a2a.types import (
-            AuthorizationCodeOAuthFlow,
-            ClientCredentialsOAuthFlow,
-            OAuth2SecurityScheme,
-            OAuthFlows,
-        )
-
-        client_credentials = None
-        authorization_code = None
-
-        if self.token_url:
-            client_credentials = ClientCredentialsOAuthFlow(
-                token_url=str(self.token_url),
-                refresh_url=str(self.refresh_url) if self.refresh_url else None,
-                scopes=self.scopes,
-            )
-
-        if self.authorization_url:
-            authorization_code = AuthorizationCodeOAuthFlow(
-                authorization_url=str(self.authorization_url),
-                token_url=str(self.token_url),
-                refresh_url=str(self.refresh_url) if self.refresh_url else None,
-                scopes=self.scopes,
-            )
-
-        return OAuth2SecurityScheme(
-            flows=OAuthFlows(
-                client_credentials=client_credentials,
-                authorization_code=authorization_code,
-            ),
-            description="OAuth2 authentication",
-        )
-
-
-class APIKeyServerAuth(ServerAuthScheme):
-    """API Key authentication for A2A server.
-
-    Validates requests using an API key in a header, query parameter, or cookie.
-
-    Attributes:
-        name: The name of the API key parameter (default: X-API-Key).
-        location: Where to look for the API key (header, query, or cookie).
-        api_key: The expected API key value.
-    """
-
-    name: str = Field(
-        default="X-API-Key",
-        description="Name of the API key parameter",
-    )
-    location: Literal["header", "query", "cookie"] = Field(
-        default="header",
-        description="Where to look for the API key",
-    )
-    api_key: CoercedSecretStr = Field(
-        description="Expected API key value",
-    )
-
-    async def authenticate(self, token: str) -> AuthenticatedUser:
-        """Authenticate using API key comparison.
-
-        Args:
-            token: The API key to authenticate.
-
-        Returns:
-            AuthenticatedUser on successful authentication.
-
-        Raises:
-            HTTPException: If authentication fails.
-        """
-        if token != self.api_key.get_secret_value():
-            raise HTTPException(
-                status_code=HTTP_401_UNAUTHORIZED,
-                detail="Invalid API key",
-            )
-
-        return AuthenticatedUser(
-            token=token,
-            scheme="api_key",
-        )
-
-
-class MTLSServerAuth(ServerAuthScheme):
-    """Mutual TLS authentication marker for AgentCard declaration.
-
-    This scheme is primarily for AgentCard security_schemes declaration.
-    Actual mTLS verification happens at the TLS/transport layer, not
-    at the application layer via token validation.
-
-    When configured, this signals to clients that the server requires
-    client certificates for authentication.
-    """
-
-    description: str = Field(
-        default="Mutual TLS certificate authentication",
-        description="Description for the security scheme",
-    )
-
-    async def authenticate(self, token: str) -> AuthenticatedUser:
-        """Return authenticated user for mTLS.
-
-        mTLS verification happens at the transport layer before this is called.
-        If we reach this point, the TLS handshake with client cert succeeded.
-
-        Args:
-            token: Certificate subject or identifier (from TLS layer).
-
-        Returns:
-            AuthenticatedUser indicating mTLS authentication.
-        """
-        return AuthenticatedUser(
-            token=token or "mtls-verified",
-            scheme="mtls",
-        )

lib/crewai/src/crewai/a2a/auth/utils.py

@@ -6,10 +6,8 @@ OAuth2, API keys, and HTTP authentication methods.
 
 import asyncio
 from collections.abc import Awaitable, Callable, MutableMapping
-import hashlib
 import re
-import threading
-from typing import Final, Literal, cast
+from typing import Final
 
 from a2a.client.errors import A2AClientHTTPError
 from a2a.types import (
@@ -20,10 +18,10 @@ from a2a.types import (
 )
 from httpx import AsyncClient, Response
 
-from crewai.a2a.auth.client_schemes import (
+from crewai.a2a.auth.schemas import (
     APIKeyAuth,
+    AuthScheme,
     BearerTokenAuth,
-    ClientAuthScheme,
     HTTPBasicAuth,
     HTTPDigestAuth,
     OAuth2AuthorizationCode,
@@ -31,44 +29,12 @@ from crewai.a2a.auth.client_schemes import (
 )
 
 
-class _AuthStore:
-    """Store for authentication schemes with safe concurrent access."""
-
-    def __init__(self) -> None:
-        self._store: dict[str, ClientAuthScheme | None] = {}
-        self._lock = threading.RLock()
-
-    @staticmethod
-    def compute_key(auth_type: str, auth_data: str) -> str:
-        """Compute a collision-resistant key using SHA-256."""
-        content = f"{auth_type}:{auth_data}"
-        return hashlib.sha256(content.encode()).hexdigest()
-
-    def set(self, key: str, auth: ClientAuthScheme | None) -> None:
-        """Store an auth scheme."""
-        with self._lock:
-            self._store[key] = auth
-
-    def get(self, key: str) -> ClientAuthScheme | None:
-        """Retrieve an auth scheme by key."""
-        with self._lock:
-            return self._store.get(key)
-
-    def __setitem__(self, key: str, value: ClientAuthScheme | None) -> None:
-        with self._lock:
-            self._store[key] = value
-
-    def __getitem__(self, key: str) -> ClientAuthScheme | None:
-        with self._lock:
-            return self._store[key]
-
-
-_auth_store = _AuthStore()
+_auth_store: dict[int, AuthScheme | None] = {}
 
 _SCHEME_PATTERN: Final[re.Pattern[str]] = re.compile(r"(\w+)\s+(.+?)(?=,\s*\w+\s+|$)")
 _PARAM_PATTERN: Final[re.Pattern[str]] = re.compile(r'(\w+)=(?:"([^"]*)"|([^\s,]+))')
 
-_SCHEME_AUTH_MAPPING: Final[dict[type, tuple[type[ClientAuthScheme], ...]]] = {
+_SCHEME_AUTH_MAPPING: Final[dict[type, tuple[type[AuthScheme], ...]]] = {
     OAuth2SecurityScheme: (
         OAuth2ClientCredentials,
         OAuth2AuthorizationCode,
@@ -77,9 +43,7 @@ _SCHEME_AUTH_MAPPING: Final[dict[type, tuple[type[ClientAuthScheme], ...]]] = {
     APIKeySecurityScheme: (APIKeyAuth,),
 }
 
-_HTTPSchemeType = Literal["basic", "digest", "bearer"]
-
-_HTTP_SCHEME_MAPPING: Final[dict[_HTTPSchemeType, type[ClientAuthScheme]]] = {
+_HTTP_SCHEME_MAPPING: Final[dict[str, type[AuthScheme]]] = {
     "basic": HTTPBasicAuth,
     "digest": HTTPDigestAuth,
     "bearer": BearerTokenAuth,
@@ -87,8 +51,8 @@ _HTTP_SCHEME_MAPPING: Final[dict[_HTTPSchemeType, type[ClientAuthScheme]]] = {
 
 
 def _raise_auth_mismatch(
-    expected_classes: type[ClientAuthScheme] | tuple[type[ClientAuthScheme], ...],
-    provided_auth: ClientAuthScheme,
+    expected_classes: type[AuthScheme] | tuple[type[AuthScheme], ...],
+    provided_auth: AuthScheme,
 ) -> None:
     """Raise authentication mismatch error.
 
@@ -147,7 +111,7 @@ def parse_www_authenticate(header_value: str) -> dict[str, dict[str, str]]:
 
 
 def validate_auth_against_agent_card(
-    agent_card: AgentCard, auth: ClientAuthScheme | None
+    agent_card: AgentCard, auth: AuthScheme | None
 ) -> None:
     """Validate that provided auth matches AgentCard security requirements.
 
@@ -181,8 +145,7 @@ def validate_auth_against_agent_card(
             return
 
         if isinstance(scheme, HTTPAuthSecurityScheme):
-            scheme_key = cast(_HTTPSchemeType, scheme.scheme.lower())
-            if required_class := _HTTP_SCHEME_MAPPING.get(scheme_key):
+            if required_class := _HTTP_SCHEME_MAPPING.get(scheme.scheme.lower()):
                 if not isinstance(auth, required_class):
                     _raise_auth_mismatch(required_class, auth)
             return
@@ -193,7 +156,7 @@ def validate_auth_against_agent_card(
 
 async def retry_on_401(
     request_func: Callable[[], Awaitable[Response]],
-    auth_scheme: ClientAuthScheme | None,
+    auth_scheme: AuthScheme | None,
     client: AsyncClient,
     headers: MutableMapping[str, str],
     max_retries: int = 3,

lib/crewai/src/crewai/a2a/config.py

@@ -5,25 +5,14 @@ This module is separate from experimental.a2a to avoid circular imports.
 
 from __future__ import annotations
 
-from pathlib import Path
-from typing import Any, ClassVar, Literal, cast
-import warnings
+from importlib.metadata import version
+from typing import Any, ClassVar, Literal
 
-from pydantic import (
-    BaseModel,
-    ConfigDict,
-    Field,
-    FilePath,
-    PrivateAttr,
-    SecretStr,
-    model_validator,
-)
-from typing_extensions import Self, deprecated
+from pydantic import BaseModel, ConfigDict, Field
+from typing_extensions import deprecated
 
-from crewai.a2a.auth.client_schemes import ClientAuthScheme
-from crewai.a2a.auth.server_schemes import ServerAuthScheme
-from crewai.a2a.extensions.base import ValidatedA2AExtension
-from crewai.a2a.types import ProtocolVersion, TransportType, Url
+from crewai.a2a.auth.schemas import AuthScheme
+from crewai.a2a.types import TransportType, Url
 
 
 try:
@@ -36,17 +25,16 @@ try:
         SecurityScheme,
     )
 
-    from crewai.a2a.extensions.server import ServerExtension
     from crewai.a2a.updates import UpdateConfig
 except ImportError:
-    UpdateConfig: Any = Any  # type: ignore[no-redef]
-    AgentCapabilities: Any = Any  # type: ignore[no-redef]
-    AgentCardSignature: Any = Any  # type: ignore[no-redef]
-    AgentInterface: Any = Any  # type: ignore[no-redef]
-    AgentProvider: Any = Any  # type: ignore[no-redef]
-    SecurityScheme: Any = Any  # type: ignore[no-redef]
-    AgentSkill: Any = Any  # type: ignore[no-redef]
-    ServerExtension: Any = Any  # type: ignore[no-redef]
+    UpdateConfig = Any
+    AgentCapabilities = Any
+    AgentCardSignature = Any
+    AgentInterface = Any
+    AgentProvider = Any
+    SecurityScheme = Any
+    AgentSkill = Any
+    UpdateConfig = Any  # type: ignore[misc,assignment]
 
 
 def _get_default_update_config() -> UpdateConfig:
@@ -55,309 +43,6 @@ def _get_default_update_config() -> UpdateConfig:
     return StreamingConfig()
 
 
-SigningAlgorithm = Literal[
-    "RS256",
-    "RS384",
-    "RS512",
-    "ES256",
-    "ES384",
-    "ES512",
-    "PS256",
-    "PS384",
-    "PS512",
-]
-
-
-class AgentCardSigningConfig(BaseModel):
-    """Configuration for AgentCard JWS signing.
-
-    Provides the private key and algorithm settings for signing AgentCards.
-    Either private_key_path or private_key_pem must be provided, but not both.
-
-    Attributes:
-        private_key_path: Path to a PEM-encoded private key file.
-        private_key_pem: PEM-encoded private key as a secret string.
-        key_id: Optional key identifier for the JWS header (kid claim).
-        algorithm: Signing algorithm (RS256, ES256, PS256, etc.).
-    """
-
-    model_config: ClassVar[ConfigDict] = ConfigDict(extra="forbid")
-
-    private_key_path: FilePath | None = Field(
-        default=None,
-        description="Path to PEM-encoded private key file",
-    )
-    private_key_pem: SecretStr | None = Field(
-        default=None,
-        description="PEM-encoded private key",
-    )
-    key_id: str | None = Field(
-        default=None,
-        description="Key identifier for JWS header (kid claim)",
-    )
-    algorithm: SigningAlgorithm = Field(
-        default="RS256",
-        description="Signing algorithm (RS256, ES256, PS256, etc.)",
-    )
-
-    @model_validator(mode="after")
-    def _validate_key_source(self) -> Self:
-        """Ensure exactly one key source is provided."""
-        has_path = self.private_key_path is not None
-        has_pem = self.private_key_pem is not None
-
-        if not has_path and not has_pem:
-            raise ValueError(
-                "Either private_key_path or private_key_pem must be provided"
-            )
-        if has_path and has_pem:
-            raise ValueError(
-                "Only one of private_key_path or private_key_pem should be provided"
-            )
-        return self
-
-    def get_private_key(self) -> str:
-        """Get the private key content.
-
-        Returns:
-            The PEM-encoded private key as a string.
-        """
-        if self.private_key_pem:
-            return self.private_key_pem.get_secret_value()
-        if self.private_key_path:
-            return Path(self.private_key_path).read_text()
-        raise ValueError("No private key configured")
-
-
-class GRPCServerConfig(BaseModel):
-    """gRPC server transport configuration.
-
-    Presence of this config in ServerTransportConfig.grpc enables gRPC transport.
-
-    Attributes:
-        host: Hostname to advertise in agent cards (default: localhost).
-            Use docker service name (e.g., 'web') for docker-compose setups.
-        port: Port for the gRPC server.
-        tls_cert_path: Path to TLS certificate file for gRPC.
-        tls_key_path: Path to TLS private key file for gRPC.
-        max_workers: Maximum number of workers for the gRPC thread pool.
-        reflection_enabled: Whether to enable gRPC reflection for debugging.
-    """
-
-    model_config: ClassVar[ConfigDict] = ConfigDict(extra="forbid")
-
-    host: str = Field(
-        default="localhost",
-        description="Hostname to advertise in agent cards for gRPC connections",
-    )
-    port: int = Field(
-        default=50051,
-        description="Port for the gRPC server",
-    )
-    tls_cert_path: str | None = Field(
-        default=None,
-        description="Path to TLS certificate file for gRPC",
-    )
-    tls_key_path: str | None = Field(
-        default=None,
-        description="Path to TLS private key file for gRPC",
-    )
-    max_workers: int = Field(
-        default=10,
-        description="Maximum number of workers for the gRPC thread pool",
-    )
-    reflection_enabled: bool = Field(
-        default=False,
-        description="Whether to enable gRPC reflection for debugging",
-    )
-
-
-class GRPCClientConfig(BaseModel):
-    """gRPC client transport configuration.
-
-    Attributes:
-        max_send_message_length: Maximum size for outgoing messages in bytes.
-        max_receive_message_length: Maximum size for incoming messages in bytes.
-        keepalive_time_ms: Time between keepalive pings in milliseconds.
-        keepalive_timeout_ms: Timeout for keepalive ping response in milliseconds.
-    """
-
-    model_config: ClassVar[ConfigDict] = ConfigDict(extra="forbid")
-
-    max_send_message_length: int | None = Field(
-        default=None,
-        description="Maximum size for outgoing messages in bytes",
-    )
-    max_receive_message_length: int | None = Field(
-        default=None,
-        description="Maximum size for incoming messages in bytes",
-    )
-    keepalive_time_ms: int | None = Field(
-        default=None,
-        description="Time between keepalive pings in milliseconds",
-    )
-    keepalive_timeout_ms: int | None = Field(
-        default=None,
-        description="Timeout for keepalive ping response in milliseconds",
-    )
-
-
-class JSONRPCServerConfig(BaseModel):
-    """JSON-RPC server transport configuration.
-
-    Presence of this config in ServerTransportConfig.jsonrpc enables JSON-RPC transport.
-
-    Attributes:
-        rpc_path: URL path for the JSON-RPC endpoint.
-        agent_card_path: URL path for the agent card endpoint.
-    """
-
-    model_config: ClassVar[ConfigDict] = ConfigDict(extra="forbid")
-
-    rpc_path: str = Field(
-        default="/a2a",
-        description="URL path for the JSON-RPC endpoint",
-    )
-    agent_card_path: str = Field(
-        default="/.well-known/agent-card.json",
-        description="URL path for the agent card endpoint",
-    )
-
-
-class JSONRPCClientConfig(BaseModel):
-    """JSON-RPC client transport configuration.
-
-    Attributes:
-        max_request_size: Maximum request body size in bytes.
-    """
-
-    model_config: ClassVar[ConfigDict] = ConfigDict(extra="forbid")
-
-    max_request_size: int | None = Field(
-        default=None,
-        description="Maximum request body size in bytes",
-    )
-
-
-class HTTPJSONConfig(BaseModel):
-    """HTTP+JSON transport configuration.
-
-    Presence of this config in ServerTransportConfig.http_json enables HTTP+JSON transport.
-    """
-
-    model_config: ClassVar[ConfigDict] = ConfigDict(extra="forbid")
-
-
-class ServerPushNotificationConfig(BaseModel):
-    """Configuration for outgoing webhook push notifications.
-
-    Controls how the server signs and delivers push notifications to clients.
-
-    Attributes:
-        signature_secret: Shared secret for HMAC-SHA256 signing of outgoing webhooks.
-    """
-
-    model_config: ClassVar[ConfigDict] = ConfigDict(extra="forbid")
-
-    signature_secret: SecretStr | None = Field(
-        default=None,
-        description="Shared secret for HMAC-SHA256 signing of outgoing push notifications",
-    )
-
-
-class ServerTransportConfig(BaseModel):
-    """Transport configuration for A2A server.
-
-    Groups all transport-related settings including preferred transport
-    and protocol-specific configurations.
-
-    Attributes:
-        preferred: Transport protocol for the preferred endpoint.
-        jsonrpc: JSON-RPC server transport configuration.
-        grpc: gRPC server transport configuration.
-        http_json: HTTP+JSON transport configuration.
-    """
-
-    model_config: ClassVar[ConfigDict] = ConfigDict(extra="forbid")
-
-    preferred: TransportType = Field(
-        default="JSONRPC",
-        description="Transport protocol for the preferred endpoint",
-    )
-    jsonrpc: JSONRPCServerConfig = Field(
-        default_factory=JSONRPCServerConfig,
-        description="JSON-RPC server transport configuration",
-    )
-    grpc: GRPCServerConfig | None = Field(
-        default=None,
-        description="gRPC server transport configuration",
-    )
-    http_json: HTTPJSONConfig | None = Field(
-        default=None,
-        description="HTTP+JSON transport configuration",
-    )
-
-
-def _migrate_client_transport_fields(
-    transport: ClientTransportConfig,
-    transport_protocol: TransportType | None,
-    supported_transports: list[TransportType] | None,
-) -> None:
-    """Migrate deprecated transport fields to new config."""
-    if transport_protocol is not None:
-        warnings.warn(
-            "transport_protocol is deprecated, use transport=ClientTransportConfig(preferred=...) instead",
-            FutureWarning,
-            stacklevel=5,
-        )
-        object.__setattr__(transport, "preferred", transport_protocol)
-    if supported_transports is not None:
-        warnings.warn(
-            "supported_transports is deprecated, use transport=ClientTransportConfig(supported=...) instead",
-            FutureWarning,
-            stacklevel=5,
-        )
-        object.__setattr__(transport, "supported", supported_transports)
-
-
-class ClientTransportConfig(BaseModel):
-    """Transport configuration for A2A client.
-
-    Groups all client transport-related settings including preferred transport,
-    supported transports for negotiation, and protocol-specific configurations.
-
-    Transport negotiation logic:
-    1. If `preferred` is set and server supports it → use client's preferred
-    2. Otherwise, if server's preferred is in client's `supported` → use server's preferred
-    3. Otherwise, find first match from client's `supported` in server's interfaces
-
-    Attributes:
-        preferred: Client's preferred transport. If set, client preference takes priority.
-        supported: Transports the client can use, in order of preference.
-        jsonrpc: JSON-RPC client transport configuration.
-        grpc: gRPC client transport configuration.
-    """
-
-    model_config: ClassVar[ConfigDict] = ConfigDict(extra="forbid")
-
-    preferred: TransportType | None = Field(
-        default=None,
-        description="Client's preferred transport. If set, takes priority over server preference.",
-    )
-    supported: list[TransportType] = Field(
-        default_factory=lambda: cast(list[TransportType], ["JSONRPC"]),
-        description="Transports the client can use, in order of preference",
-    )
-    jsonrpc: JSONRPCClientConfig = Field(
-        default_factory=JSONRPCClientConfig,
-        description="JSON-RPC client transport configuration",
-    )
-    grpc: GRPCClientConfig = Field(
-        default_factory=GRPCClientConfig,
-        description="gRPC client transport configuration",
-    )
-
-
 @deprecated(
     """
     `crewai.a2a.config.A2AConfig` is deprecated and will be removed in v2.0.0,
@@ -380,14 +65,13 @@ class A2AConfig(BaseModel):
         fail_fast: If True, raise error when agent unreachable; if False, skip and continue.
         trust_remote_completion_status: If True, return A2A agent's result directly when completed.
         updates: Update mechanism config.
-        client_extensions: Client-side processing hooks for tool injection and prompt augmentation.
-        transport: Transport configuration (preferred, supported transports, gRPC settings).
+        transport_protocol: A2A transport protocol (grpc, jsonrpc, http+json).
     """
 
     model_config: ClassVar[ConfigDict] = ConfigDict(extra="forbid")
 
     endpoint: Url = Field(description="A2A agent endpoint URL")
-    auth: ClientAuthScheme | None = Field(
+    auth: AuthScheme | None = Field(
         default=None,
         description="Authentication scheme",
     )
@@ -411,48 +95,10 @@ class A2AConfig(BaseModel):
         default_factory=_get_default_update_config,
         description="Update mechanism config",
     )
-    client_extensions: list[ValidatedA2AExtension] = Field(
-        default_factory=list,
-        description="Client-side processing hooks for tool injection and prompt augmentation",
+    transport_protocol: Literal["JSONRPC", "GRPC", "HTTP+JSON"] = Field(
+        default="JSONRPC",
+        description="Specified mode of A2A transport protocol",
     )
-    transport: ClientTransportConfig = Field(
-        default_factory=ClientTransportConfig,
-        description="Transport configuration (preferred, supported transports, gRPC settings)",
-    )
-    transport_protocol: TransportType | None = Field(
-        default=None,
-        description="Deprecated: Use transport.preferred instead",
-        exclude=True,
-    )
-    supported_transports: list[TransportType] | None = Field(
-        default=None,
-        description="Deprecated: Use transport.supported instead",
-        exclude=True,
-    )
-    use_client_preference: bool | None = Field(
-        default=None,
-        description="Deprecated: Set transport.preferred to enable client preference",
-        exclude=True,
-    )
-    _parallel_delegation: bool = PrivateAttr(default=False)
-
-    @model_validator(mode="after")
-    def _migrate_deprecated_transport_fields(self) -> Self:
-        """Migrate deprecated transport fields to new config."""
-        _migrate_client_transport_fields(
-            self.transport, self.transport_protocol, self.supported_transports
-        )
-        if self.use_client_preference is not None:
-            warnings.warn(
-                "use_client_preference is deprecated, set transport.preferred to enable client preference",
-                FutureWarning,
-                stacklevel=4,
-            )
-            if self.use_client_preference and self.transport.supported:
-                object.__setattr__(
-                    self.transport, "preferred", self.transport.supported[0]
-                )
-        return self
 
 
 class A2AClientConfig(BaseModel):
@@ -468,15 +114,15 @@ class A2AClientConfig(BaseModel):
         trust_remote_completion_status: If True, return A2A agent's result directly when completed.
         updates: Update mechanism config.
         accepted_output_modes: Media types the client can accept in responses.
-        extensions: Extension URIs the client supports (A2A protocol extensions).
-        client_extensions: Client-side processing hooks for tool injection and prompt augmentation.
-        transport: Transport configuration (preferred, supported transports, gRPC settings).
+        supported_transports: Ordered list of transport protocols the client supports.
+        use_client_preference: Whether to prioritize client transport preferences over server.
+        extensions: Extension URIs the client supports.
     """
 
     model_config: ClassVar[ConfigDict] = ConfigDict(extra="forbid")
 
     endpoint: Url = Field(description="A2A agent endpoint URL")
-    auth: ClientAuthScheme | None = Field(
+    auth: AuthScheme | None = Field(
         default=None,
         description="Authentication scheme",
     )
@@ -504,37 +150,22 @@ class A2AClientConfig(BaseModel):
         default_factory=lambda: ["application/json"],
         description="Media types the client can accept in responses",
     )
+    supported_transports: list[str] = Field(
+        default_factory=lambda: ["JSONRPC"],
+        description="Ordered list of transport protocols the client supports",
+    )
+    use_client_preference: bool = Field(
+        default=False,
+        description="Whether to prioritize client transport preferences over server",
+    )
     extensions: list[str] = Field(
         default_factory=list,
         description="Extension URIs the client supports",
     )
-    client_extensions: list[ValidatedA2AExtension] = Field(
-        default_factory=list,
-        description="Client-side processing hooks for tool injection and prompt augmentation",
+    transport_protocol: Literal["JSONRPC", "GRPC", "HTTP+JSON"] = Field(
+        default="JSONRPC",
+        description="Specified mode of A2A transport protocol",
     )
-    transport: ClientTransportConfig = Field(
-        default_factory=ClientTransportConfig,
-        description="Transport configuration (preferred, supported transports, gRPC settings)",
-    )
-    transport_protocol: TransportType | None = Field(
-        default=None,
-        description="Deprecated: Use transport.preferred instead",
-        exclude=True,
-    )
-    supported_transports: list[TransportType] | None = Field(
-        default=None,
-        description="Deprecated: Use transport.supported instead",
-        exclude=True,
-    )
-    _parallel_delegation: bool = PrivateAttr(default=False)
-
-    @model_validator(mode="after")
-    def _migrate_deprecated_transport_fields(self) -> Self:
-        """Migrate deprecated transport fields to new config."""
-        _migrate_client_transport_fields(
-            self.transport, self.transport_protocol, self.supported_transports
-        )
-        return self
 
 
 class A2AServerConfig(BaseModel):
@@ -551,6 +182,7 @@ class A2AServerConfig(BaseModel):
         default_input_modes: Default supported input MIME types.
         default_output_modes: Default supported output MIME types.
         capabilities: Declaration of optional capabilities.
+        preferred_transport: Transport protocol for the preferred endpoint.
         protocol_version: A2A protocol version this agent supports.
         provider: Information about the agent's service provider.
         documentation_url: URL to the agent's documentation.
@@ -560,12 +192,7 @@ class A2AServerConfig(BaseModel):
         security_schemes: Security schemes available to authorize requests.
         supports_authenticated_extended_card: Whether agent provides extended card to authenticated users.
         url: Preferred endpoint URL for the agent.
-        signing_config: Configuration for signing the AgentCard with JWS.
-        signatures: Deprecated. Pre-computed JWS signatures. Use signing_config instead.
-        server_extensions: Server-side A2A protocol extensions with on_request/on_response hooks.
-        push_notifications: Configuration for outgoing push notifications.
-        transport: Transport configuration (preferred transport, gRPC, REST settings).
-        auth: Authentication scheme for A2A endpoints.
+        signatures: JSON Web Signatures for the AgentCard.
     """
 
     model_config: ClassVar[ConfigDict] = ConfigDict(extra="forbid")
@@ -601,8 +228,12 @@ class A2AServerConfig(BaseModel):
         ),
         description="Declaration of optional capabilities supported by the agent",
     )
-    protocol_version: ProtocolVersion = Field(
-        default="0.3.0",
+    preferred_transport: TransportType = Field(
+        default="JSONRPC",
+        description="Transport protocol for the preferred endpoint",
+    )
+    protocol_version: str = Field(
+        default_factory=lambda: version("a2a-sdk"),
         description="A2A protocol version this agent supports",
     )
     provider: AgentProvider | None = Field(
@@ -619,7 +250,7 @@ class A2AServerConfig(BaseModel):
     )
     additional_interfaces: list[AgentInterface] = Field(
         default_factory=list,
-        description="Additional supported interfaces.",
+        description="Additional supported interfaces (transport and URL combinations)",
     )
     security: list[dict[str, list[str]]] = Field(
         default_factory=list,
@@ -637,54 +268,7 @@ class A2AServerConfig(BaseModel):
         default=None,
         description="Preferred endpoint URL for the agent. Set at runtime if not provided.",
     )
-    signing_config: AgentCardSigningConfig | None = Field(
-        default=None,
-        description="Configuration for signing the AgentCard with JWS",
-    )
-    signatures: list[AgentCardSignature] | None = Field(
-        default=None,
-        description="Deprecated: Use signing_config instead. Pre-computed JWS signatures for the AgentCard.",
-        exclude=True,
-        deprecated=True,
-    )
-    server_extensions: list[ServerExtension] = Field(
+    signatures: list[AgentCardSignature] = Field(
         default_factory=list,
-        description="Server-side A2A protocol extensions that modify agent behavior",
+        description="JSON Web Signatures for the AgentCard",
     )
-    push_notifications: ServerPushNotificationConfig | None = Field(
-        default=None,
-        description="Configuration for outgoing push notifications",
-    )
-    transport: ServerTransportConfig = Field(
-        default_factory=ServerTransportConfig,
-        description="Transport configuration (preferred transport, gRPC, REST settings)",
-    )
-    preferred_transport: TransportType | None = Field(
-        default=None,
-        description="Deprecated: Use transport.preferred instead",
-        exclude=True,
-        deprecated=True,
-    )
-    auth: ServerAuthScheme | None = Field(
-        default=None,
-        description="Authentication scheme for A2A endpoints. Defaults to SimpleTokenAuth using AUTH_TOKEN env var.",
-    )
-
-    @model_validator(mode="after")
-    def _migrate_deprecated_fields(self) -> Self:
-        """Migrate deprecated fields to new config."""
-        if self.preferred_transport is not None:
-            warnings.warn(
-                "preferred_transport is deprecated, use transport=ServerTransportConfig(preferred=...) instead",
-                FutureWarning,
-                stacklevel=4,
-            )
-            object.__setattr__(self.transport, "preferred", self.preferred_transport)
-        if self.signatures is not None:
-            warnings.warn(
-                "signatures is deprecated, use signing_config=AgentCardSigningConfig(...) instead. "
-                "The signatures field will be removed in v2.0.0.",
-                FutureWarning,
-                stacklevel=4,
-            )
-        return self

lib/crewai/src/crewai/a2a/errors.py

@@ -1,491 +1,7 @@
-"""A2A error codes and error response utilities.
-
-This module provides a centralized mapping of all A2A protocol error codes
-as defined in the A2A specification, plus custom CrewAI extensions.
-
-Error codes follow JSON-RPC 2.0 conventions:
-- -32700 to -32600: Standard JSON-RPC errors
-- -32099 to -32000: Server errors (A2A-specific)
-- -32768 to -32100: Reserved for implementation-defined errors
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from enum import IntEnum
-from typing import Any
+"""A2A protocol error types."""
 
 from a2a.client.errors import A2AClientTimeoutError
 
 
 class A2APollingTimeoutError(A2AClientTimeoutError):
     """Raised when polling exceeds the configured timeout."""
-
-
-class A2AErrorCode(IntEnum):
-    """A2A protocol error codes.
-
-    Codes follow JSON-RPC 2.0 specification with A2A-specific extensions.
-    """
-
-    # JSON-RPC 2.0 Standard Errors (-32700 to -32600)
-    JSON_PARSE_ERROR = -32700
-    """Invalid JSON was received by the server."""
-
-    INVALID_REQUEST = -32600
-    """The JSON sent is not a valid Request object."""
-
-    METHOD_NOT_FOUND = -32601
-    """The method does not exist / is not available."""
-
-    INVALID_PARAMS = -32602
-    """Invalid method parameter(s)."""
-
-    INTERNAL_ERROR = -32603
-    """Internal JSON-RPC error."""
-
-    # A2A-Specific Errors (-32099 to -32000)
-    TASK_NOT_FOUND = -32001
-    """The specified task was not found."""
-
-    TASK_NOT_CANCELABLE = -32002
-    """The task cannot be canceled (already completed/failed)."""
-
-    PUSH_NOTIFICATION_NOT_SUPPORTED = -32003
-    """Push notifications are not supported by this agent."""
-
-    UNSUPPORTED_OPERATION = -32004
-    """The requested operation is not supported."""
-
-    CONTENT_TYPE_NOT_SUPPORTED = -32005
-    """Incompatible content types between client and server."""
-
-    INVALID_AGENT_RESPONSE = -32006
-    """The agent produced an invalid response."""
-
-    # CrewAI Custom Extensions (-32768 to -32100)
-    UNSUPPORTED_VERSION = -32009
-    """The requested A2A protocol version is not supported."""
-
-    UNSUPPORTED_EXTENSION = -32010
-    """Client does not support required protocol extensions."""
-
-    AUTHENTICATION_REQUIRED = -32011
-    """Authentication is required for this operation."""
-
-    AUTHORIZATION_FAILED = -32012
-    """Authorization check failed (insufficient permissions)."""
-
-    RATE_LIMIT_EXCEEDED = -32013
-    """Rate limit exceeded for this client/operation."""
-
-    TASK_TIMEOUT = -32014
-    """Task execution timed out."""
-
-    TRANSPORT_NEGOTIATION_FAILED = -32015
-    """Failed to negotiate a compatible transport protocol."""
-
-    CONTEXT_NOT_FOUND = -32016
-    """The specified context was not found."""
-
-    SKILL_NOT_FOUND = -32017
-    """The specified skill was not found."""
-
-    ARTIFACT_NOT_FOUND = -32018
-    """The specified artifact was not found."""
-
-
-# Error code to default message mapping
-ERROR_MESSAGES: dict[int, str] = {
-    A2AErrorCode.JSON_PARSE_ERROR: "Parse error",
-    A2AErrorCode.INVALID_REQUEST: "Invalid Request",
-    A2AErrorCode.METHOD_NOT_FOUND: "Method not found",
-    A2AErrorCode.INVALID_PARAMS: "Invalid params",
-    A2AErrorCode.INTERNAL_ERROR: "Internal error",
-    A2AErrorCode.TASK_NOT_FOUND: "Task not found",
-    A2AErrorCode.TASK_NOT_CANCELABLE: "Task not cancelable",
-    A2AErrorCode.PUSH_NOTIFICATION_NOT_SUPPORTED: "Push Notification is not supported",
-    A2AErrorCode.UNSUPPORTED_OPERATION: "This operation is not supported",
-    A2AErrorCode.CONTENT_TYPE_NOT_SUPPORTED: "Incompatible content types",
-    A2AErrorCode.INVALID_AGENT_RESPONSE: "Invalid agent response",
-    A2AErrorCode.UNSUPPORTED_VERSION: "Unsupported A2A version",
-    A2AErrorCode.UNSUPPORTED_EXTENSION: "Client does not support required extensions",
-    A2AErrorCode.AUTHENTICATION_REQUIRED: "Authentication required",
-    A2AErrorCode.AUTHORIZATION_FAILED: "Authorization failed",
-    A2AErrorCode.RATE_LIMIT_EXCEEDED: "Rate limit exceeded",
-    A2AErrorCode.TASK_TIMEOUT: "Task execution timed out",
-    A2AErrorCode.TRANSPORT_NEGOTIATION_FAILED: "Transport negotiation failed",
-    A2AErrorCode.CONTEXT_NOT_FOUND: "Context not found",
-    A2AErrorCode.SKILL_NOT_FOUND: "Skill not found",
-    A2AErrorCode.ARTIFACT_NOT_FOUND: "Artifact not found",
-}
-
-
-@dataclass
-class A2AError(Exception):
-    """Base exception for A2A protocol errors.
-
-    Attributes:
-        code: The A2A/JSON-RPC error code.
-        message: Human-readable error message.
-        data: Optional additional error data.
-    """
-
-    code: int
-    message: str | None = None
-    data: Any = None
-
-    def __post_init__(self) -> None:
-        if self.message is None:
-            self.message = ERROR_MESSAGES.get(self.code, "Unknown error")
-        super().__init__(self.message)
-
-    def to_dict(self) -> dict[str, Any]:
-        """Convert to JSON-RPC error object format."""
-        error: dict[str, Any] = {
-            "code": self.code,
-            "message": self.message,
-        }
-        if self.data is not None:
-            error["data"] = self.data
-        return error
-
-    def to_response(self, request_id: str | int | None = None) -> dict[str, Any]:
-        """Convert to full JSON-RPC error response."""
-        return {
-            "jsonrpc": "2.0",
-            "error": self.to_dict(),
-            "id": request_id,
-        }
-
-
-@dataclass
-class JSONParseError(A2AError):
-    """Invalid JSON was received."""
-
-    code: int = field(default=A2AErrorCode.JSON_PARSE_ERROR, init=False)
-
-
-@dataclass
-class InvalidRequestError(A2AError):
-    """The JSON sent is not a valid Request object."""
-
-    code: int = field(default=A2AErrorCode.INVALID_REQUEST, init=False)
-
-
-@dataclass
-class MethodNotFoundError(A2AError):
-    """The method does not exist / is not available."""
-
-    code: int = field(default=A2AErrorCode.METHOD_NOT_FOUND, init=False)
-    method: str | None = None
-
-    def __post_init__(self) -> None:
-        if self.message is None and self.method:
-            self.message = f"Method not found: {self.method}"
-        super().__post_init__()
-
-
-@dataclass
-class InvalidParamsError(A2AError):
-    """Invalid method parameter(s)."""
-
-    code: int = field(default=A2AErrorCode.INVALID_PARAMS, init=False)
-    param: str | None = None
-    reason: str | None = None
-
-    def __post_init__(self) -> None:
-        if self.message is None:
-            if self.param and self.reason:
-                self.message = f"Invalid parameter '{self.param}': {self.reason}"
-            elif self.param:
-                self.message = f"Invalid parameter: {self.param}"
-        super().__post_init__()
-
-
-@dataclass
-class InternalError(A2AError):
-    """Internal JSON-RPC error."""
-
-    code: int = field(default=A2AErrorCode.INTERNAL_ERROR, init=False)
-
-
-@dataclass
-class TaskNotFoundError(A2AError):
-    """The specified task was not found."""
-
-    code: int = field(default=A2AErrorCode.TASK_NOT_FOUND, init=False)
-    task_id: str | None = None
-
-    def __post_init__(self) -> None:
-        if self.message is None and self.task_id:
-            self.message = f"Task not found: {self.task_id}"
-        super().__post_init__()
-
-
-@dataclass
-class TaskNotCancelableError(A2AError):
-    """The task cannot be canceled."""
-
-    code: int = field(default=A2AErrorCode.TASK_NOT_CANCELABLE, init=False)
-    task_id: str | None = None
-    reason: str | None = None
-
-    def __post_init__(self) -> None:
-        if self.message is None:
-            if self.task_id and self.reason:
-                self.message = f"Task {self.task_id} cannot be canceled: {self.reason}"
-            elif self.task_id:
-                self.message = f"Task {self.task_id} cannot be canceled"
-        super().__post_init__()
-
-
-@dataclass
-class PushNotificationNotSupportedError(A2AError):
-    """Push notifications are not supported."""
-
-    code: int = field(default=A2AErrorCode.PUSH_NOTIFICATION_NOT_SUPPORTED, init=False)
-
-
-@dataclass
-class UnsupportedOperationError(A2AError):
-    """The requested operation is not supported."""
-
-    code: int = field(default=A2AErrorCode.UNSUPPORTED_OPERATION, init=False)
-    operation: str | None = None
-
-    def __post_init__(self) -> None:
-        if self.message is None and self.operation:
-            self.message = f"Operation not supported: {self.operation}"
-        super().__post_init__()
-
-
-@dataclass
-class ContentTypeNotSupportedError(A2AError):
-    """Incompatible content types."""
-
-    code: int = field(default=A2AErrorCode.CONTENT_TYPE_NOT_SUPPORTED, init=False)
-    requested_types: list[str] | None = None
-    supported_types: list[str] | None = None
-
-    def __post_init__(self) -> None:
-        if self.message is None and self.requested_types and self.supported_types:
-            self.message = (
-                f"Content type not supported. Requested: {self.requested_types}, "
-                f"Supported: {self.supported_types}"
-            )
-        super().__post_init__()
-
-
-@dataclass
-class InvalidAgentResponseError(A2AError):
-    """The agent produced an invalid response."""
-
-    code: int = field(default=A2AErrorCode.INVALID_AGENT_RESPONSE, init=False)
-
-
-@dataclass
-class UnsupportedVersionError(A2AError):
-    """The requested A2A version is not supported."""
-
-    code: int = field(default=A2AErrorCode.UNSUPPORTED_VERSION, init=False)
-    requested_version: str | None = None
-    supported_versions: list[str] | None = None
-
-    def __post_init__(self) -> None:
-        if self.message is None and self.requested_version:
-            msg = f"Unsupported A2A version: {self.requested_version}"
-            if self.supported_versions:
-                msg += f". Supported versions: {', '.join(self.supported_versions)}"
-            self.message = msg
-        super().__post_init__()
-
-
-@dataclass
-class UnsupportedExtensionError(A2AError):
-    """Client does not support required extensions."""
-
-    code: int = field(default=A2AErrorCode.UNSUPPORTED_EXTENSION, init=False)
-    required_extensions: list[str] | None = None
-
-    def __post_init__(self) -> None:
-        if self.message is None and self.required_extensions:
-            self.message = f"Client does not support required extensions: {', '.join(self.required_extensions)}"
-        super().__post_init__()
-
-
-@dataclass
-class AuthenticationRequiredError(A2AError):
-    """Authentication is required."""
-
-    code: int = field(default=A2AErrorCode.AUTHENTICATION_REQUIRED, init=False)
-
-
-@dataclass
-class AuthorizationFailedError(A2AError):
-    """Authorization check failed."""
-
-    code: int = field(default=A2AErrorCode.AUTHORIZATION_FAILED, init=False)
-    required_scope: str | None = None
-
-    def __post_init__(self) -> None:
-        if self.message is None and self.required_scope:
-            self.message = (
-                f"Authorization failed. Required scope: {self.required_scope}"
-            )
-        super().__post_init__()
-
-
-@dataclass
-class RateLimitExceededError(A2AError):
-    """Rate limit exceeded."""
-
-    code: int = field(default=A2AErrorCode.RATE_LIMIT_EXCEEDED, init=False)
-    retry_after: int | None = None
-
-    def __post_init__(self) -> None:
-        if self.message is None and self.retry_after:
-            self.message = (
-                f"Rate limit exceeded. Retry after {self.retry_after} seconds"
-            )
-        if self.retry_after:
-            self.data = {"retry_after": self.retry_after}
-        super().__post_init__()
-
-
-@dataclass
-class TaskTimeoutError(A2AError):
-    """Task execution timed out."""
-
-    code: int = field(default=A2AErrorCode.TASK_TIMEOUT, init=False)
-    task_id: str | None = None
-    timeout_seconds: float | None = None
-
-    def __post_init__(self) -> None:
-        if self.message is None:
-            if self.task_id and self.timeout_seconds:
-                self.message = (
-                    f"Task {self.task_id} timed out after {self.timeout_seconds}s"
-                )
-            elif self.task_id:
-                self.message = f"Task {self.task_id} timed out"
-        super().__post_init__()
-
-
-@dataclass
-class TransportNegotiationFailedError(A2AError):
-    """Failed to negotiate a compatible transport protocol."""
-
-    code: int = field(default=A2AErrorCode.TRANSPORT_NEGOTIATION_FAILED, init=False)
-    client_transports: list[str] | None = None
-    server_transports: list[str] | None = None
-
-    def __post_init__(self) -> None:
-        if self.message is None and self.client_transports and self.server_transports:
-            self.message = (
-                f"Transport negotiation failed. Client: {self.client_transports}, "
-                f"Server: {self.server_transports}"
-            )
-        super().__post_init__()
-
-
-@dataclass
-class ContextNotFoundError(A2AError):
-    """The specified context was not found."""
-
-    code: int = field(default=A2AErrorCode.CONTEXT_NOT_FOUND, init=False)
-    context_id: str | None = None
-
-    def __post_init__(self) -> None:
-        if self.message is None and self.context_id:
-            self.message = f"Context not found: {self.context_id}"
-        super().__post_init__()
-
-
-@dataclass
-class SkillNotFoundError(A2AError):
-    """The specified skill was not found."""
-
-    code: int = field(default=A2AErrorCode.SKILL_NOT_FOUND, init=False)
-    skill_id: str | None = None
-
-    def __post_init__(self) -> None:
-        if self.message is None and self.skill_id:
-            self.message = f"Skill not found: {self.skill_id}"
-        super().__post_init__()
-
-
-@dataclass
-class ArtifactNotFoundError(A2AError):
-    """The specified artifact was not found."""
-
-    code: int = field(default=A2AErrorCode.ARTIFACT_NOT_FOUND, init=False)
-    artifact_id: str | None = None
-
-    def __post_init__(self) -> None:
-        if self.message is None and self.artifact_id:
-            self.message = f"Artifact not found: {self.artifact_id}"
-        super().__post_init__()
-
-
-def create_error_response(
-    code: int | A2AErrorCode,
-    message: str | None = None,
-    data: Any = None,
-    request_id: str | int | None = None,
-) -> dict[str, Any]:
-    """Create a JSON-RPC error response.
-
-    Args:
-        code: Error code (A2AErrorCode or int).
-        message: Optional error message (uses default if not provided).
-        data: Optional additional error data.
-        request_id: Request ID for correlation.
-
-    Returns:
-        Dict in JSON-RPC error response format.
-    """
-    error = A2AError(code=int(code), message=message, data=data)
-    return error.to_response(request_id)
-
-
-def is_retryable_error(code: int) -> bool:
-    """Check if an error is potentially retryable.
-
-    Args:
-        code: Error code to check.
-
-    Returns:
-        True if the error might be resolved by retrying.
-    """
-    retryable_codes = {
-        A2AErrorCode.INTERNAL_ERROR,
-        A2AErrorCode.RATE_LIMIT_EXCEEDED,
-        A2AErrorCode.TASK_TIMEOUT,
-    }
-    return code in retryable_codes
-
-
-def is_client_error(code: int) -> bool:
-    """Check if an error is a client-side error.
-
-    Args:
-        code: Error code to check.
-
-    Returns:
-        True if the error is due to client request issues.
-    """
-    client_error_codes = {
-        A2AErrorCode.JSON_PARSE_ERROR,
-        A2AErrorCode.INVALID_REQUEST,
-        A2AErrorCode.METHOD_NOT_FOUND,
-        A2AErrorCode.INVALID_PARAMS,
-        A2AErrorCode.TASK_NOT_FOUND,
-        A2AErrorCode.CONTENT_TYPE_NOT_SUPPORTED,
-        A2AErrorCode.UNSUPPORTED_VERSION,
-        A2AErrorCode.UNSUPPORTED_EXTENSION,
-        A2AErrorCode.CONTEXT_NOT_FOUND,
-        A2AErrorCode.SKILL_NOT_FOUND,
-        A2AErrorCode.ARTIFACT_NOT_FOUND,
-    }
-    return code in client_error_codes

lib/crewai/src/crewai/a2a/extensions/__init__.py

@@ -1,37 +1,4 @@
 """A2A Protocol Extensions for CrewAI.
 
 This module contains extensions to the A2A (Agent-to-Agent) protocol.
-
-**Client-side extensions** (A2AExtension) allow customizing how the A2A wrapper
-processes requests and responses during delegation to remote agents. These provide
-hooks for tool injection, prompt augmentation, and response processing.
-
-**Server-side extensions** (ServerExtension) allow agents to offer additional
-functionality beyond the core A2A specification. Clients activate extensions
-via the X-A2A-Extensions header.
-
-See: https://a2a-protocol.org/latest/topics/extensions/
 """
-
-from crewai.a2a.extensions.base import (
-    A2AExtension,
-    ConversationState,
-    ExtensionRegistry,
-    ValidatedA2AExtension,
-)
-from crewai.a2a.extensions.server import (
-    ExtensionContext,
-    ServerExtension,
-    ServerExtensionRegistry,
-)
-
-
-__all__ = [
-    "A2AExtension",
-    "ConversationState",
-    "ExtensionContext",
-    "ExtensionRegistry",
-    "ServerExtension",
-    "ServerExtensionRegistry",
-    "ValidatedA2AExtension",
-]

lib/crewai/src/crewai/a2a/extensions/base.py

@@ -1,20 +1,14 @@
-"""Base extension interface for CrewAI A2A wrapper processing hooks.
+"""Base extension interface for A2A wrapper integrations.
 
-This module defines the protocol for extending CrewAI's A2A wrapper functionality
-with custom logic for tool injection, prompt augmentation, and response processing.
-
-Note: These are CrewAI-specific processing hooks, NOT A2A protocol extensions.
-A2A protocol extensions are capability declarations using AgentExtension objects
-in AgentCard.capabilities.extensions, activated via the A2A-Extensions HTTP header.
-See: https://a2a-protocol.org/latest/topics/extensions/
+This module defines the protocol for extending A2A wrapper functionality
+with custom logic for conversation processing, prompt augmentation, and
+agent response handling.
 """
 
 from __future__ import annotations
 
 from collections.abc import Sequence
-from typing import TYPE_CHECKING, Annotated, Any, Protocol, runtime_checkable
-
-from pydantic import BeforeValidator
+from typing import TYPE_CHECKING, Any, Protocol
 
 
 if TYPE_CHECKING:
@@ -23,20 +17,6 @@ if TYPE_CHECKING:
     from crewai.agent.core import Agent
 
 
-def _validate_a2a_extension(v: Any) -> Any:
-    """Validate that value implements A2AExtension protocol."""
-    if not isinstance(v, A2AExtension):
-        raise ValueError(
-            f"Value must implement A2AExtension protocol. "
-            f"Got {type(v).__name__} which is missing required methods."
-        )
-    return v
-
-
-ValidatedA2AExtension = Annotated[Any, BeforeValidator(_validate_a2a_extension)]
-
-
-@runtime_checkable
 class ConversationState(Protocol):
     """Protocol for extension-specific conversation state.
 
@@ -53,36 +33,11 @@ class ConversationState(Protocol):
         ...
 
 
-@runtime_checkable
 class A2AExtension(Protocol):
     """Protocol for A2A wrapper extensions.
 
     Extensions can implement this protocol to inject custom logic into
     the A2A conversation flow at various integration points.
-
-    Example:
-        class MyExtension:
-            def inject_tools(self, agent: Agent) -> None:
-                # Add custom tools to the agent
-                pass
-
-            def extract_state_from_history(
-                self, conversation_history: Sequence[Message]
-            ) -> ConversationState | None:
-                # Extract state from conversation
-                return None
-
-            def augment_prompt(
-                self, base_prompt: str, conversation_state: ConversationState | None
-            ) -> str:
-                # Add custom instructions
-                return base_prompt
-
-            def process_response(
-                self, agent_response: Any, conversation_state: ConversationState | None
-            ) -> Any:
-                # Modify response if needed
-                return agent_response
     """
 
     def inject_tools(self, agent: Agent) -> None:

lib/crewai/src/crewai/a2a/extensions/registry.py

@@ -1,170 +1,34 @@
-"""A2A Protocol extension utilities.
+"""Extension registry factory for A2A configurations.
 
-This module provides utilities for working with A2A protocol extensions as
-defined in the A2A specification. Extensions are capability declarations in
-AgentCard.capabilities.extensions using AgentExtension objects, activated
-via the X-A2A-Extensions HTTP header.
-
-See: https://a2a-protocol.org/latest/topics/extensions/
+This module provides utilities for creating extension registries from A2A configurations.
 """
 
 from __future__ import annotations
 
-from typing import Any
+from typing import TYPE_CHECKING
 
-from a2a.client.middleware import ClientCallContext, ClientCallInterceptor
-from a2a.extensions.common import (
-    HTTP_EXTENSION_HEADER,
-)
-from a2a.types import AgentCard, AgentExtension
-
-from crewai.a2a.config import A2AClientConfig, A2AConfig
 from crewai.a2a.extensions.base import ExtensionRegistry
 
 
-def get_extensions_from_config(
-    a2a_config: list[A2AConfig | A2AClientConfig] | A2AConfig | A2AClientConfig,
-) -> list[str]:
-    """Extract extension URIs from A2A configuration.
-
-    Args:
-        a2a_config: A2A configuration (single or list).
-
-    Returns:
-        Deduplicated list of extension URIs from all configs.
-    """
-    configs = a2a_config if isinstance(a2a_config, list) else [a2a_config]
-    seen: set[str] = set()
-    result: list[str] = []
-
-    for config in configs:
-        if not isinstance(config, A2AClientConfig):
-            continue
-        for uri in config.extensions:
-            if uri not in seen:
-                seen.add(uri)
-                result.append(uri)
-
-    return result
-
-
-class ExtensionsMiddleware(ClientCallInterceptor):
-    """Middleware to add X-A2A-Extensions header to requests.
-
-    This middleware adds the extensions header to all outgoing requests,
-    declaring which A2A protocol extensions the client supports.
-    """
-
-    def __init__(self, extensions: list[str]) -> None:
-        """Initialize with extension URIs.
-
-        Args:
-            extensions: List of extension URIs the client supports.
-        """
-        self._extensions = extensions
-
-    async def intercept(
-        self,
-        method_name: str,
-        request_payload: dict[str, Any],
-        http_kwargs: dict[str, Any],
-        agent_card: AgentCard | None,
-        context: ClientCallContext | None,
-    ) -> tuple[dict[str, Any], dict[str, Any]]:
-        """Add extensions header to the request.
-
-        Args:
-            method_name: The A2A method being called.
-            request_payload: The JSON-RPC request payload.
-            http_kwargs: HTTP request kwargs (headers, etc).
-            agent_card: The target agent's card.
-            context: Optional call context.
-
-        Returns:
-            Tuple of (request_payload, modified_http_kwargs).
-        """
-        if self._extensions:
-            headers = http_kwargs.setdefault("headers", {})
-            headers[HTTP_EXTENSION_HEADER] = ",".join(self._extensions)
-        return request_payload, http_kwargs
-
-
-def validate_required_extensions(
-    agent_card: AgentCard,
-    client_extensions: list[str] | None,
-) -> list[AgentExtension]:
-    """Validate that client supports all required extensions from agent.
-
-    Args:
-        agent_card: The agent's card with declared extensions.
-        client_extensions: Extension URIs the client supports.
-
-    Returns:
-        List of unsupported required extensions.
-
-    Raises:
-        None - returns list of unsupported extensions for caller to handle.
-    """
-    unsupported: list[AgentExtension] = []
-    client_set = set(client_extensions or [])
-
-    if not agent_card.capabilities or not agent_card.capabilities.extensions:
-        return unsupported
-
-    unsupported.extend(
-        ext
-        for ext in agent_card.capabilities.extensions
-        if ext.required and ext.uri not in client_set
-    )
-
-    return unsupported
+if TYPE_CHECKING:
+    from crewai.a2a.config import A2AConfig
 
 
 def create_extension_registry_from_config(
-    a2a_config: list[A2AConfig | A2AClientConfig] | A2AConfig | A2AClientConfig,
+    a2a_config: list[A2AConfig] | A2AConfig,
 ) -> ExtensionRegistry:
-    """Create an extension registry from A2A client configuration.
-
-    Extracts client_extensions from each A2AClientConfig and registers them
-    with the ExtensionRegistry. These extensions provide CrewAI-specific
-    processing hooks (tool injection, prompt augmentation, response processing).
-
-    Note: A2A protocol extensions (URI strings sent via X-A2A-Extensions header)
-    are handled separately via get_extensions_from_config() and ExtensionsMiddleware.
+    """Create an extension registry from A2A configuration.
 
     Args:
-        a2a_config: A2A configuration (single or list).
+        a2a_config: A2A configuration (single or list)
 
     Returns:
-        Extension registry with all client_extensions registered.
-
-    Example:
-        class LoggingExtension:
-            def inject_tools(self, agent): pass
-            def extract_state_from_history(self, history): return None
-            def augment_prompt(self, prompt, state): return prompt
-            def process_response(self, response, state):
-                print(f"Response: {response}")
-                return response
-
-        config = A2AClientConfig(
-            endpoint="https://agent.example.com",
-            client_extensions=[LoggingExtension()],
-        )
-        registry = create_extension_registry_from_config(config)
+        Configured extension registry with all applicable extensions
     """
     registry = ExtensionRegistry()
     configs = a2a_config if isinstance(a2a_config, list) else [a2a_config]
 
-    seen: set[int] = set()
-
-    for config in configs:
-        if isinstance(config, (A2AConfig, A2AClientConfig)):
-            client_exts = getattr(config, "client_extensions", [])
-            for extension in client_exts:
-                ext_id = id(extension)
-                if ext_id not in seen:
-                    seen.add(ext_id)
-                    registry.register(extension)
+    for _ in configs:
+        pass
 
     return registry

lib/crewai/src/crewai/a2a/extensions/server.py

@@ -1,305 +0,0 @@
-"""A2A protocol server extensions for CrewAI agents.
-
-This module provides the base class and context for implementing A2A protocol
-extensions on the server side. Extensions allow agents to offer additional
-functionality beyond the core A2A specification.
-
-See: https://a2a-protocol.org/latest/topics/extensions/
-"""
-
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from dataclasses import dataclass, field
-import logging
-from typing import TYPE_CHECKING, Annotated, Any
-
-from a2a.types import AgentExtension
-from pydantic_core import CoreSchema, core_schema
-
-
-if TYPE_CHECKING:
-    from a2a.server.context import ServerCallContext
-    from pydantic import GetCoreSchemaHandler
-
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class ExtensionContext:
-    """Context passed to extension hooks during request processing.
-
-    Provides access to request metadata, client extensions, and shared state
-    that extensions can read from and write to.
-
-    Attributes:
-        metadata: Request metadata dict, includes extension-namespaced keys.
-        client_extensions: Set of extension URIs the client declared support for.
-        state: Mutable dict for extensions to share data during request lifecycle.
-        server_context: The underlying A2A server call context.
-    """
-
-    metadata: dict[str, Any]
-    client_extensions: set[str]
-    state: dict[str, Any] = field(default_factory=dict)
-    server_context: ServerCallContext | None = None
-
-    def get_extension_metadata(self, uri: str, key: str) -> Any | None:
-        """Get extension-specific metadata value.
-
-        Extension metadata uses namespaced keys in the format:
-        "{extension_uri}/{key}"
-
-        Args:
-            uri: The extension URI.
-            key: The metadata key within the extension namespace.
-
-        Returns:
-            The metadata value, or None if not present.
-        """
-        full_key = f"{uri}/{key}"
-        return self.metadata.get(full_key)
-
-    def set_extension_metadata(self, uri: str, key: str, value: Any) -> None:
-        """Set extension-specific metadata value.
-
-        Args:
-            uri: The extension URI.
-            key: The metadata key within the extension namespace.
-            value: The value to set.
-        """
-        full_key = f"{uri}/{key}"
-        self.metadata[full_key] = value
-
-
-class ServerExtension(ABC):
-    """Base class for A2A protocol server extensions.
-
-    Subclass this to create custom extensions that modify agent behavior
-    when clients activate them. Extensions are identified by URI and can
-    be marked as required.
-
-    Example:
-        class SamplingExtension(ServerExtension):
-            uri = "urn:crewai:ext:sampling/v1"
-            required = True
-
-            def __init__(self, max_tokens: int = 4096):
-                self.max_tokens = max_tokens
-
-            @property
-            def params(self) -> dict[str, Any]:
-                return {"max_tokens": self.max_tokens}
-
-            async def on_request(self, context: ExtensionContext) -> None:
-                limit = context.get_extension_metadata(self.uri, "limit")
-                if limit:
-                    context.state["token_limit"] = int(limit)
-
-            async def on_response(self, context: ExtensionContext, result: Any) -> Any:
-                return result
-    """
-
-    uri: Annotated[str, "Extension URI identifier. Must be unique."]
-    required: Annotated[bool, "Whether clients must support this extension."] = False
-    description: Annotated[
-        str | None, "Human-readable description of the extension."
-    ] = None
-
-    @classmethod
-    def __get_pydantic_core_schema__(
-        cls,
-        _source_type: Any,
-        _handler: GetCoreSchemaHandler,
-    ) -> CoreSchema:
-        """Tell Pydantic how to validate ServerExtension instances."""
-        return core_schema.is_instance_schema(cls)
-
-    @property
-    def params(self) -> dict[str, Any] | None:
-        """Extension parameters to advertise in AgentCard.
-
-        Override this property to expose configuration that clients can read.
-
-        Returns:
-            Dict of parameter names to values, or None.
-        """
-        return None
-
-    def agent_extension(self) -> AgentExtension:
-        """Generate the AgentExtension object for the AgentCard.
-
-        Returns:
-            AgentExtension with this extension's URI, required flag, and params.
-        """
-        return AgentExtension(
-            uri=self.uri,
-            required=self.required if self.required else None,
-            description=self.description,
-            params=self.params,
-        )
-
-    def is_active(self, context: ExtensionContext) -> bool:
-        """Check if this extension is active for the current request.
-
-        An extension is active if the client declared support for it.
-
-        Args:
-            context: The extension context for the current request.
-
-        Returns:
-            True if the client supports this extension.
-        """
-        return self.uri in context.client_extensions
-
-    @abstractmethod
-    async def on_request(self, context: ExtensionContext) -> None:
-        """Called before agent execution if extension is active.
-
-        Use this hook to:
-        - Read extension-specific metadata from the request
-        - Set up state for the execution
-        - Modify execution parameters via context.state
-
-        Args:
-            context: The extension context with request metadata and state.
-        """
-        ...
-
-    @abstractmethod
-    async def on_response(self, context: ExtensionContext, result: Any) -> Any:
-        """Called after agent execution if extension is active.
-
-        Use this hook to:
-        - Modify or enhance the result
-        - Add extension-specific metadata to the response
-        - Clean up any resources
-
-        Args:
-            context: The extension context with request metadata and state.
-            result: The agent execution result.
-
-        Returns:
-            The result, potentially modified.
-        """
-        ...
-
-
-class ServerExtensionRegistry:
-    """Registry for managing server-side A2A protocol extensions.
-
-    Collects extensions and provides methods to generate AgentCapabilities
-    and invoke extension hooks during request processing.
-    """
-
-    def __init__(self, extensions: list[ServerExtension] | None = None) -> None:
-        """Initialize the registry with optional extensions.
-
-        Args:
-            extensions: Initial list of extensions to register.
-        """
-        self._extensions: list[ServerExtension] = list(extensions) if extensions else []
-        self._by_uri: dict[str, ServerExtension] = {
-            ext.uri: ext for ext in self._extensions
-        }
-
-    def register(self, extension: ServerExtension) -> None:
-        """Register an extension.
-
-        Args:
-            extension: The extension to register.
-
-        Raises:
-            ValueError: If an extension with the same URI is already registered.
-        """
-        if extension.uri in self._by_uri:
-            raise ValueError(f"Extension already registered: {extension.uri}")
-        self._extensions.append(extension)
-        self._by_uri[extension.uri] = extension
-
-    def get_agent_extensions(self) -> list[AgentExtension]:
-        """Get AgentExtension objects for all registered extensions.
-
-        Returns:
-            List of AgentExtension objects for the AgentCard.
-        """
-        return [ext.agent_extension() for ext in self._extensions]
-
-    def get_extension(self, uri: str) -> ServerExtension | None:
-        """Get an extension by URI.
-
-        Args:
-            uri: The extension URI.
-
-        Returns:
-            The extension, or None if not found.
-        """
-        return self._by_uri.get(uri)
-
-    @staticmethod
-    def create_context(
-        metadata: dict[str, Any],
-        client_extensions: set[str],
-        server_context: ServerCallContext | None = None,
-    ) -> ExtensionContext:
-        """Create an ExtensionContext for a request.
-
-        Args:
-            metadata: Request metadata dict.
-            client_extensions: Set of extension URIs from client.
-            server_context: Optional server call context.
-
-        Returns:
-            ExtensionContext for use in hooks.
-        """
-        return ExtensionContext(
-            metadata=metadata,
-            client_extensions=client_extensions,
-            server_context=server_context,
-        )
-
-    async def invoke_on_request(self, context: ExtensionContext) -> None:
-        """Invoke on_request hooks for all active extensions.
-
-        Tracks activated extensions and isolates errors from individual hooks.
-
-        Args:
-            context: The extension context for the request.
-        """
-        for extension in self._extensions:
-            if extension.is_active(context):
-                try:
-                    await extension.on_request(context)
-                    if context.server_context is not None:
-                        context.server_context.activated_extensions.add(extension.uri)
-                except Exception:
-                    logger.exception(
-                        "Extension on_request hook failed",
-                        extra={"extension": extension.uri},
-                    )
-
-    async def invoke_on_response(self, context: ExtensionContext, result: Any) -> Any:
-        """Invoke on_response hooks for all active extensions.
-
-        Isolates errors from individual hooks to prevent one failing extension
-        from breaking the entire response.
-
-        Args:
-            context: The extension context for the request.
-            result: The agent execution result.
-
-        Returns:
-            The result after all extensions have processed it.
-        """
-        processed = result
-        for extension in self._extensions:
-            if extension.is_active(context):
-                try:
-                    processed = await extension.on_response(context, processed)
-                except Exception:
-                    logger.exception(
-                        "Extension on_response hook failed",
-                        extra={"extension": extension.uri},
-                    )
-        return processed

lib/crewai/src/crewai/a2a/task_helpers.py

@@ -51,13 +51,6 @@ ACTIONABLE_STATES: frozenset[TaskState] = frozenset(
     }
 )
 
-PENDING_STATES: frozenset[TaskState] = frozenset(
-    {
-        TaskState.submitted,
-        TaskState.working,
-    }
-)
-
 
 class TaskStateResult(TypedDict):
     """Result dictionary from processing A2A task state."""
@@ -279,9 +272,6 @@ def process_task_state(
             history=new_messages,
         )
 
-    if a2a_task.status.state in PENDING_STATES:
-        return None
-
     return None
 
 

lib/crewai/src/crewai/a2a/templates.py

@@ -38,18 +38,3 @@ You MUST now:
 DO NOT send another request - the task is already done.
 </REMOTE_AGENT_STATUS>
 """
-
-REMOTE_AGENT_RESPONSE_NOTICE: Final[str] = """
-<REMOTE_AGENT_STATUS>
-STATUS: RESPONSE_RECEIVED
-The remote agent has responded. Their response is in the conversation history above.
-
-You MUST now:
-1. Set is_a2a=false (the remote task is complete and cannot receive more messages)
-2. Provide YOUR OWN response to the original task based on the information received
-
-IMPORTANT: Your response should be addressed to the USER who gave you the original task.
-Report what the remote agent told you in THIRD PERSON (e.g., "The remote agent said..." or "I learned that...").
-Do NOT address the remote agent directly or use "you" to refer to them.
-</REMOTE_AGENT_STATUS>
-"""

lib/crewai/src/crewai/a2a/types.py

@@ -36,17 +36,6 @@ except ImportError:
 
 
 TransportType = Literal["JSONRPC", "GRPC", "HTTP+JSON"]
-ProtocolVersion = Literal[
-    "0.2.0",
-    "0.2.1",
-    "0.2.2",
-    "0.2.3",
-    "0.2.4",
-    "0.2.5",
-    "0.2.6",
-    "0.3.0",
-    "0.4.0",
-]
 
 http_url_adapter: TypeAdapter[HttpUrl] = TypeAdapter(HttpUrl)
 

lib/crewai/src/crewai/a2a/updates/base.py

@@ -2,28 +2,12 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, NamedTuple, Protocol, TypedDict
+from typing import TYPE_CHECKING, Any, Protocol, TypedDict
 
 from pydantic import GetCoreSchemaHandler
 from pydantic_core import CoreSchema, core_schema
 
 
-class CommonParams(NamedTuple):
-    """Common parameters shared across all update handlers.
-
-    Groups the frequently-passed parameters to reduce duplication.
-    """
-
-    turn_number: int
-    is_multiturn: bool
-    agent_role: str | None
-    endpoint: str
-    a2a_agent_name: str | None
-    context_id: str | None
-    from_task: Any
-    from_agent: Any
-
-
 if TYPE_CHECKING:
     from a2a.client import Client
     from a2a.types import AgentCard, Message, Task
@@ -79,8 +63,8 @@ class PushNotificationResultStore(Protocol):
     @classmethod
     def __get_pydantic_core_schema__(
         cls,
-        _source_type: Any,
-        _handler: GetCoreSchemaHandler,
+        source_type: Any,
+        handler: GetCoreSchemaHandler,
     ) -> CoreSchema:
         return core_schema.any_schema()
 
@@ -146,31 +130,3 @@ class UpdateHandler(Protocol):
             Result dictionary with status, result/error, and history.
         """
         ...
-
-
-def extract_common_params(kwargs: BaseHandlerKwargs) -> CommonParams:
-    """Extract common parameters from handler kwargs.
-
-    Args:
-        kwargs: Handler kwargs dict.
-
-    Returns:
-        CommonParams with extracted values.
-
-    Raises:
-        ValueError: If endpoint is not provided.
-    """
-    endpoint = kwargs.get("endpoint")
-    if endpoint is None:
-        raise ValueError("endpoint is required for update handlers")
-
-    return CommonParams(
-        turn_number=kwargs.get("turn_number", 0),
-        is_multiturn=kwargs.get("is_multiturn", False),
-        agent_role=kwargs.get("agent_role"),
-        endpoint=endpoint,
-        a2a_agent_name=kwargs.get("a2a_agent_name"),
-        context_id=kwargs.get("context_id"),
-        from_task=kwargs.get("from_task"),
-        from_agent=kwargs.get("from_agent"),
-    )

lib/crewai/src/crewai/a2a/updates/polling/handler.py

@@ -94,7 +94,7 @@ async def _poll_task_until_complete(
             A2APollingStatusEvent(
                 task_id=task_id,
                 context_id=effective_context_id,
-                state=str(task.status.state.value),
+                state=str(task.status.state.value) if task.status.state else "unknown",
                 elapsed_seconds=elapsed,
                 poll_count=poll_count,
                 endpoint=endpoint,
@@ -325,7 +325,7 @@ class PollingHandler:
             crewai_event_bus.emit(
                 agent_branch,
                 A2AConnectionErrorEvent(
-                    endpoint=endpoint,
+                    endpoint=endpoint or "",
                     error=str(e),
                     error_type="unexpected_error",
                     a2a_agent_name=a2a_agent_name,

lib/crewai/src/crewai/a2a/updates/push_notifications/config.py

@@ -2,30 +2,10 @@
 
 from __future__ import annotations
 
-from typing import Annotated
-
 from a2a.types import PushNotificationAuthenticationInfo
-from pydantic import AnyHttpUrl, BaseModel, BeforeValidator, Field
+from pydantic import AnyHttpUrl, BaseModel, Field
 
 from crewai.a2a.updates.base import PushNotificationResultStore
-from crewai.a2a.updates.push_notifications.signature import WebhookSignatureConfig
-
-
-def _coerce_signature(
-    value: str | WebhookSignatureConfig | None,
-) -> WebhookSignatureConfig | None:
-    """Convert string secret to WebhookSignatureConfig."""
-    if value is None:
-        return None
-    if isinstance(value, str):
-        return WebhookSignatureConfig.hmac_sha256(secret=value)
-    return value
-
-
-SignatureInput = Annotated[
-    WebhookSignatureConfig | None,
-    BeforeValidator(_coerce_signature),
-]
 
 
 class PushNotificationConfig(BaseModel):
@@ -39,8 +19,6 @@ class PushNotificationConfig(BaseModel):
         timeout: Max seconds to wait for task completion.
         interval: Seconds between result polling attempts.
         result_store: Store for receiving push notification results.
-        signature: HMAC signature config. Pass a string (secret) for defaults,
-            or WebhookSignatureConfig for custom settings.
     """
 
     url: AnyHttpUrl = Field(description="Callback URL for push notifications")
@@ -58,8 +36,3 @@ class PushNotificationConfig(BaseModel):
     result_store: PushNotificationResultStore | None = Field(
         default=None, description="Result store for push notification handling"
     )
-    signature: SignatureInput = Field(
-        default=None,
-        description="HMAC signature config. Pass a string (secret) for simple usage, "
-        "or WebhookSignatureConfig for custom headers/tolerance.",
-    )

lib/crewai/src/crewai/a2a/updates/push_notifications/handler.py

@@ -24,10 +24,8 @@ from crewai.a2a.task_helpers import (
     send_message_and_get_task_id,
 )
 from crewai.a2a.updates.base import (
-    CommonParams,
     PushNotificationHandlerKwargs,
     PushNotificationResultStore,
-    extract_common_params,
 )
 from crewai.events.event_bus import crewai_event_bus
 from crewai.events.types.a2a_events import (
@@ -41,81 +39,10 @@ from crewai.events.types.a2a_events import (
 if TYPE_CHECKING:
     from a2a.types import Task as A2ATask
 
+
 logger = logging.getLogger(__name__)
 
 
-def _handle_push_error(
-    error: Exception,
-    error_msg: str,
-    error_type: str,
-    new_messages: list[Message],
-    agent_branch: Any | None,
-    params: CommonParams,
-    task_id: str | None,
-    status_code: int | None = None,
-) -> TaskStateResult:
-    """Handle push notification errors with consistent event emission.
-
-    Args:
-        error: The exception that occurred.
-        error_msg: Formatted error message for the result.
-        error_type: Type of error for the event.
-        new_messages: List to append error message to.
-        agent_branch: Agent tree branch for events.
-        params: Common handler parameters.
-        task_id: A2A task ID.
-        status_code: HTTP status code if applicable.
-
-    Returns:
-        TaskStateResult with failed status.
-    """
-    error_message = Message(
-        role=Role.agent,
-        message_id=str(uuid.uuid4()),
-        parts=[Part(root=TextPart(text=error_msg))],
-        context_id=params.context_id,
-        task_id=task_id,
-    )
-    new_messages.append(error_message)
-
-    crewai_event_bus.emit(
-        agent_branch,
-        A2AConnectionErrorEvent(
-            endpoint=params.endpoint,
-            error=str(error),
-            error_type=error_type,
-            status_code=status_code,
-            a2a_agent_name=params.a2a_agent_name,
-            operation="push_notification",
-            context_id=params.context_id,
-            task_id=task_id,
-            from_task=params.from_task,
-            from_agent=params.from_agent,
-        ),
-    )
-    crewai_event_bus.emit(
-        agent_branch,
-        A2AResponseReceivedEvent(
-            response=error_msg,
-            turn_number=params.turn_number,
-            context_id=params.context_id,
-            is_multiturn=params.is_multiturn,
-            status="failed",
-            final=True,
-            agent_role=params.agent_role,
-            endpoint=params.endpoint,
-            a2a_agent_name=params.a2a_agent_name,
-            from_task=params.from_task,
-            from_agent=params.from_agent,
-        ),
-    )
-    return TaskStateResult(
-        status=TaskState.failed,
-        error=error_msg,
-        history=new_messages,
-    )
-
-
 async def _wait_for_push_result(
     task_id: str,
     result_store: PushNotificationResultStore,
@@ -199,8 +126,15 @@ class PushNotificationHandler:
         polling_timeout = kwargs.get("polling_timeout", 300.0)
         polling_interval = kwargs.get("polling_interval", 2.0)
         agent_branch = kwargs.get("agent_branch")
+        turn_number = kwargs.get("turn_number", 0)
+        is_multiturn = kwargs.get("is_multiturn", False)
+        agent_role = kwargs.get("agent_role")
+        context_id = kwargs.get("context_id")
         task_id = kwargs.get("task_id")
-        params = extract_common_params(kwargs)
+        endpoint = kwargs.get("endpoint")
+        a2a_agent_name = kwargs.get("a2a_agent_name")
+        from_task = kwargs.get("from_task")
+        from_agent = kwargs.get("from_agent")
 
         if config is None:
             error_msg = (
@@ -209,15 +143,15 @@ class PushNotificationHandler:
             crewai_event_bus.emit(
                 agent_branch,
                 A2AConnectionErrorEvent(
-                    endpoint=params.endpoint,
+                    endpoint=endpoint or "",
                     error=error_msg,
                     error_type="configuration_error",
-                    a2a_agent_name=params.a2a_agent_name,
+                    a2a_agent_name=a2a_agent_name,
                     operation="push_notification",
-                    context_id=params.context_id,
+                    context_id=context_id,
                     task_id=task_id,
-                    from_task=params.from_task,
-                    from_agent=params.from_agent,
+                    from_task=from_task,
+                    from_agent=from_agent,
                 ),
             )
             return TaskStateResult(
@@ -233,15 +167,15 @@ class PushNotificationHandler:
             crewai_event_bus.emit(
                 agent_branch,
                 A2AConnectionErrorEvent(
-                    endpoint=params.endpoint,
+                    endpoint=endpoint or "",
                     error=error_msg,
                     error_type="configuration_error",
-                    a2a_agent_name=params.a2a_agent_name,
+                    a2a_agent_name=a2a_agent_name,
                     operation="push_notification",
-                    context_id=params.context_id,
+                    context_id=context_id,
                     task_id=task_id,
-                    from_task=params.from_task,
-                    from_agent=params.from_agent,
+                    from_task=from_task,
+                    from_agent=from_agent,
                 ),
             )
             return TaskStateResult(
@@ -255,14 +189,14 @@ class PushNotificationHandler:
                 event_stream=client.send_message(message),
                 new_messages=new_messages,
                 agent_card=agent_card,
-                turn_number=params.turn_number,
-                is_multiturn=params.is_multiturn,
-                agent_role=params.agent_role,
-                from_task=params.from_task,
-                from_agent=params.from_agent,
-                endpoint=params.endpoint,
-                a2a_agent_name=params.a2a_agent_name,
-                context_id=params.context_id,
+                turn_number=turn_number,
+                is_multiturn=is_multiturn,
+                agent_role=agent_role,
+                from_task=from_task,
+                from_agent=from_agent,
+                endpoint=endpoint,
+                a2a_agent_name=a2a_agent_name,
+                context_id=context_id,
             )
 
             if not isinstance(result_or_task_id, str):
@@ -274,12 +208,12 @@ class PushNotificationHandler:
                 agent_branch,
                 A2APushNotificationRegisteredEvent(
                     task_id=task_id,
-                    context_id=params.context_id,
+                    context_id=context_id,
                     callback_url=str(config.url),
-                    endpoint=params.endpoint,
-                    a2a_agent_name=params.a2a_agent_name,
-                    from_task=params.from_task,
-                    from_agent=params.from_agent,
+                    endpoint=endpoint,
+                    a2a_agent_name=a2a_agent_name,
+                    from_task=from_task,
+                    from_agent=from_agent,
                 ),
             )
 
@@ -295,11 +229,11 @@ class PushNotificationHandler:
                 timeout=polling_timeout,
                 poll_interval=polling_interval,
                 agent_branch=agent_branch,
-                from_task=params.from_task,
-                from_agent=params.from_agent,
-                context_id=params.context_id,
-                endpoint=params.endpoint,
-                a2a_agent_name=params.a2a_agent_name,
+                from_task=from_task,
+                from_agent=from_agent,
+                context_id=context_id,
+                endpoint=endpoint,
+                a2a_agent_name=a2a_agent_name,
             )
 
             if final_task is None:
@@ -313,13 +247,13 @@ class PushNotificationHandler:
                 a2a_task=final_task,
                 new_messages=new_messages,
                 agent_card=agent_card,
-                turn_number=params.turn_number,
-                is_multiturn=params.is_multiturn,
-                agent_role=params.agent_role,
-                endpoint=params.endpoint,
-                a2a_agent_name=params.a2a_agent_name,
-                from_task=params.from_task,
-                from_agent=params.from_agent,
+                turn_number=turn_number,
+                is_multiturn=is_multiturn,
+                agent_role=agent_role,
+                endpoint=endpoint,
+                a2a_agent_name=a2a_agent_name,
+                from_task=from_task,
+                from_agent=from_agent,
             )
             if result:
                 return result
@@ -331,24 +265,98 @@ class PushNotificationHandler:
             )
 
         except A2AClientHTTPError as e:
-            return _handle_push_error(
-                error=e,
-                error_msg=f"HTTP Error {e.status_code}: {e!s}",
-                error_type="http_error",
-                new_messages=new_messages,
-                agent_branch=agent_branch,
-                params=params,
+            error_msg = f"HTTP Error {e.status_code}: {e!s}"
+
+            error_message = Message(
+                role=Role.agent,
+                message_id=str(uuid.uuid4()),
+                parts=[Part(root=TextPart(text=error_msg))],
+                context_id=context_id,
                 task_id=task_id,
-                status_code=e.status_code,
+            )
+            new_messages.append(error_message)
+
+            crewai_event_bus.emit(
+                agent_branch,
+                A2AConnectionErrorEvent(
+                    endpoint=endpoint or "",
+                    error=str(e),
+                    error_type="http_error",
+                    status_code=e.status_code,
+                    a2a_agent_name=a2a_agent_name,
+                    operation="push_notification",
+                    context_id=context_id,
+                    task_id=task_id,
+                    from_task=from_task,
+                    from_agent=from_agent,
+                ),
+            )
+            crewai_event_bus.emit(
+                agent_branch,
+                A2AResponseReceivedEvent(
+                    response=error_msg,
+                    turn_number=turn_number,
+                    context_id=context_id,
+                    is_multiturn=is_multiturn,
+                    status="failed",
+                    final=True,
+                    agent_role=agent_role,
+                    endpoint=endpoint,
+                    a2a_agent_name=a2a_agent_name,
+                    from_task=from_task,
+                    from_agent=from_agent,
+                ),
+            )
+            return TaskStateResult(
+                status=TaskState.failed,
+                error=error_msg,
+                history=new_messages,
             )
 
         except Exception as e:
-            return _handle_push_error(
-                error=e,
-                error_msg=f"Unexpected error during push notification: {e!s}",
-                error_type="unexpected_error",
-                new_messages=new_messages,
-                agent_branch=agent_branch,
-                params=params,
+            error_msg = f"Unexpected error during push notification: {e!s}"
+
+            error_message = Message(
+                role=Role.agent,
+                message_id=str(uuid.uuid4()),
+                parts=[Part(root=TextPart(text=error_msg))],
+                context_id=context_id,
                 task_id=task_id,
             )
+            new_messages.append(error_message)
+
+            crewai_event_bus.emit(
+                agent_branch,
+                A2AConnectionErrorEvent(
+                    endpoint=endpoint or "",
+                    error=str(e),
+                    error_type="unexpected_error",
+                    a2a_agent_name=a2a_agent_name,
+                    operation="push_notification",
+                    context_id=context_id,
+                    task_id=task_id,
+                    from_task=from_task,
+                    from_agent=from_agent,
+                ),
+            )
+            crewai_event_bus.emit(
+                agent_branch,
+                A2AResponseReceivedEvent(
+                    response=error_msg,
+                    turn_number=turn_number,
+                    context_id=context_id,
+                    is_multiturn=is_multiturn,
+                    status="failed",
+                    final=True,
+                    agent_role=agent_role,
+                    endpoint=endpoint,
+                    a2a_agent_name=a2a_agent_name,
+                    from_task=from_task,
+                    from_agent=from_agent,
+                ),
+            )
+            return TaskStateResult(
+                status=TaskState.failed,
+                error=error_msg,
+                history=new_messages,
+            )

lib/crewai/src/crewai/a2a/updates/push_notifications/signature.py

@@ -1,87 +0,0 @@
-"""Webhook signature configuration for push notifications."""
-
-from __future__ import annotations
-
-from enum import Enum
-import secrets
-
-from pydantic import BaseModel, Field, SecretStr
-
-
-class WebhookSignatureMode(str, Enum):
-    """Signature mode for webhook push notifications."""
-
-    NONE = "none"
-    HMAC_SHA256 = "hmac_sha256"
-
-
-class WebhookSignatureConfig(BaseModel):
-    """Configuration for webhook signature verification.
-
-    Provides cryptographic integrity verification and replay attack protection
-    for A2A push notifications.
-
-    Attributes:
-        mode: Signature mode (none or hmac_sha256).
-        secret: Shared secret for HMAC computation (required for hmac_sha256 mode).
-        timestamp_tolerance_seconds: Max allowed age of timestamps for replay protection.
-        header_name: HTTP header name for the signature.
-        timestamp_header_name: HTTP header name for the timestamp.
-    """
-
-    mode: WebhookSignatureMode = Field(
-        default=WebhookSignatureMode.NONE,
-        description="Signature verification mode",
-    )
-    secret: SecretStr | None = Field(
-        default=None,
-        description="Shared secret for HMAC computation",
-    )
-    timestamp_tolerance_seconds: int = Field(
-        default=300,
-        ge=0,
-        description="Max allowed timestamp age in seconds (5 min default)",
-    )
-    header_name: str = Field(
-        default="X-A2A-Signature",
-        description="HTTP header name for the signature",
-    )
-    timestamp_header_name: str = Field(
-        default="X-A2A-Signature-Timestamp",
-        description="HTTP header name for the timestamp",
-    )
-
-    @classmethod
-    def generate_secret(cls, length: int = 32) -> str:
-        """Generate a cryptographically secure random secret.
-
-        Args:
-            length: Number of random bytes to generate (default 32).
-
-        Returns:
-            URL-safe base64-encoded secret string.
-        """
-        return secrets.token_urlsafe(length)
-
-    @classmethod
-    def hmac_sha256(
-        cls,
-        secret: str | SecretStr,
-        timestamp_tolerance_seconds: int = 300,
-    ) -> WebhookSignatureConfig:
-        """Create an HMAC-SHA256 signature configuration.
-
-        Args:
-            secret: Shared secret for HMAC computation.
-            timestamp_tolerance_seconds: Max allowed timestamp age in seconds.
-
-        Returns:
-            Configured WebhookSignatureConfig for HMAC-SHA256.
-        """
-        if isinstance(secret, str):
-            secret = SecretStr(secret)
-        return cls(
-            mode=WebhookSignatureMode.HMAC_SHA256,
-            secret=secret,
-            timestamp_tolerance_seconds=timestamp_tolerance_seconds,
-        )

lib/crewai/src/crewai/a2a/updates/streaming/handler.py

@@ -2,9 +2,6 @@
 
 from __future__ import annotations
 
-import asyncio
-import logging
-from typing import Final
 import uuid
 
 from a2a.client import Client
@@ -14,10 +11,7 @@ from a2a.types import (
     Message,
     Part,
     Role,
-    Task,
     TaskArtifactUpdateEvent,
-    TaskIdParams,
-    TaskQueryParams,
     TaskState,
     TaskStatusUpdateEvent,
     TextPart,
@@ -30,10 +24,7 @@ from crewai.a2a.task_helpers import (
     TaskStateResult,
     process_task_state,
 )
-from crewai.a2a.updates.base import StreamingHandlerKwargs, extract_common_params
-from crewai.a2a.updates.streaming.params import (
-    process_status_update,
-)
+from crewai.a2a.updates.base import StreamingHandlerKwargs
 from crewai.events.event_bus import crewai_event_bus
 from crewai.events.types.a2a_events import (
     A2AArtifactReceivedEvent,
@@ -44,194 +35,9 @@ from crewai.events.types.a2a_events import (
 )
 
 
-logger = logging.getLogger(__name__)
-
-MAX_RESUBSCRIBE_ATTEMPTS: Final[int] = 3
-RESUBSCRIBE_BACKOFF_BASE: Final[float] = 1.0
-
-
 class StreamingHandler:
     """SSE streaming-based update handler."""
 
-    @staticmethod
-    async def _try_recover_from_interruption(  # type: ignore[misc]
-        client: Client,
-        task_id: str,
-        new_messages: list[Message],
-        agent_card: AgentCard,
-        result_parts: list[str],
-        **kwargs: Unpack[StreamingHandlerKwargs],
-    ) -> TaskStateResult | None:
-        """Attempt to recover from a stream interruption by checking task state.
-
-        If the task completed while we were disconnected, returns the result.
-        If the task is still running, attempts to resubscribe and continue.
-
-        Args:
-            client: A2A client instance.
-            task_id: The task ID to recover.
-            new_messages: List of collected messages.
-            agent_card: The agent card.
-            result_parts: Accumulated result text parts.
-            **kwargs: Handler parameters.
-
-        Returns:
-            TaskStateResult if recovery succeeded (task finished or resubscribe worked).
-            None if recovery not possible (caller should handle failure).
-
-        Note:
-            When None is returned, recovery failed and the original exception should
-            be handled by the caller. All recovery attempts are logged.
-        """
-        params = extract_common_params(kwargs)  # type: ignore[arg-type]
-
-        try:
-            a2a_task: Task = await client.get_task(TaskQueryParams(id=task_id))
-
-            if a2a_task.status.state in TERMINAL_STATES:
-                logger.info(
-                    "Task completed during stream interruption",
-                    extra={"task_id": task_id, "state": str(a2a_task.status.state)},
-                )
-                return process_task_state(
-                    a2a_task=a2a_task,
-                    new_messages=new_messages,
-                    agent_card=agent_card,
-                    turn_number=params.turn_number,
-                    is_multiturn=params.is_multiturn,
-                    agent_role=params.agent_role,
-                    result_parts=result_parts,
-                    endpoint=params.endpoint,
-                    a2a_agent_name=params.a2a_agent_name,
-                    from_task=params.from_task,
-                    from_agent=params.from_agent,
-                )
-
-            if a2a_task.status.state in ACTIONABLE_STATES:
-                logger.info(
-                    "Task in actionable state during stream interruption",
-                    extra={"task_id": task_id, "state": str(a2a_task.status.state)},
-                )
-                return process_task_state(
-                    a2a_task=a2a_task,
-                    new_messages=new_messages,
-                    agent_card=agent_card,
-                    turn_number=params.turn_number,
-                    is_multiturn=params.is_multiturn,
-                    agent_role=params.agent_role,
-                    result_parts=result_parts,
-                    endpoint=params.endpoint,
-                    a2a_agent_name=params.a2a_agent_name,
-                    from_task=params.from_task,
-                    from_agent=params.from_agent,
-                    is_final=False,
-                )
-
-            logger.info(
-                "Task still running, attempting resubscribe",
-                extra={"task_id": task_id, "state": str(a2a_task.status.state)},
-            )
-
-            for attempt in range(MAX_RESUBSCRIBE_ATTEMPTS):
-                try:
-                    backoff = RESUBSCRIBE_BACKOFF_BASE * (2**attempt)
-                    if attempt > 0:
-                        await asyncio.sleep(backoff)
-
-                    event_stream = client.resubscribe(TaskIdParams(id=task_id))
-
-                    async for event in event_stream:
-                        if isinstance(event, tuple):
-                            resubscribed_task, update = event
-
-                            is_final_update = (
-                                process_status_update(update, result_parts)
-                                if isinstance(update, TaskStatusUpdateEvent)
-                                else False
-                            )
-
-                            if isinstance(update, TaskArtifactUpdateEvent):
-                                artifact = update.artifact
-                                result_parts.extend(
-                                    part.root.text
-                                    for part in artifact.parts
-                                    if part.root.kind == "text"
-                                )
-
-                            if (
-                                is_final_update
-                                or resubscribed_task.status.state
-                                in TERMINAL_STATES | ACTIONABLE_STATES
-                            ):
-                                return process_task_state(
-                                    a2a_task=resubscribed_task,
-                                    new_messages=new_messages,
-                                    agent_card=agent_card,
-                                    turn_number=params.turn_number,
-                                    is_multiturn=params.is_multiturn,
-                                    agent_role=params.agent_role,
-                                    result_parts=result_parts,
-                                    endpoint=params.endpoint,
-                                    a2a_agent_name=params.a2a_agent_name,
-                                    from_task=params.from_task,
-                                    from_agent=params.from_agent,
-                                    is_final=is_final_update,
-                                )
-
-                        elif isinstance(event, Message):
-                            new_messages.append(event)
-                            result_parts.extend(
-                                part.root.text
-                                for part in event.parts
-                                if part.root.kind == "text"
-                            )
-
-                    final_task = await client.get_task(TaskQueryParams(id=task_id))
-                    return process_task_state(
-                        a2a_task=final_task,
-                        new_messages=new_messages,
-                        agent_card=agent_card,
-                        turn_number=params.turn_number,
-                        is_multiturn=params.is_multiturn,
-                        agent_role=params.agent_role,
-                        result_parts=result_parts,
-                        endpoint=params.endpoint,
-                        a2a_agent_name=params.a2a_agent_name,
-                        from_task=params.from_task,
-                        from_agent=params.from_agent,
-                    )
-
-                except Exception as resubscribe_error:  # noqa: PERF203
-                    logger.warning(
-                        "Resubscribe attempt failed",
-                        extra={
-                            "task_id": task_id,
-                            "attempt": attempt + 1,
-                            "max_attempts": MAX_RESUBSCRIBE_ATTEMPTS,
-                            "error": str(resubscribe_error),
-                        },
-                    )
-                    if attempt == MAX_RESUBSCRIBE_ATTEMPTS - 1:
-                        return None
-
-        except Exception as e:
-            logger.warning(
-                "Failed to recover from stream interruption due to unexpected error",
-                extra={
-                    "task_id": task_id,
-                    "error": str(e),
-                    "error_type": type(e).__name__,
-                },
-                exc_info=True,
-            )
-            return None
-
-        logger.warning(
-            "Recovery exhausted all resubscribe attempts without success",
-            extra={"task_id": task_id, "max_attempts": MAX_RESUBSCRIBE_ATTEMPTS},
-        )
-        return None
-
     @staticmethod
     async def execute(
         client: Client,
@@ -252,40 +58,42 @@ class StreamingHandler:
         Returns:
             Dictionary with status, result/error, and history.
         """
+        context_id = kwargs.get("context_id")
         task_id = kwargs.get("task_id")
+        turn_number = kwargs.get("turn_number", 0)
+        is_multiturn = kwargs.get("is_multiturn", False)
+        agent_role = kwargs.get("agent_role")
+        endpoint = kwargs.get("endpoint")
+        a2a_agent_name = kwargs.get("a2a_agent_name")
+        from_task = kwargs.get("from_task")
+        from_agent = kwargs.get("from_agent")
         agent_branch = kwargs.get("agent_branch")
-        params = extract_common_params(kwargs)
 
         result_parts: list[str] = []
         final_result: TaskStateResult | None = None
         event_stream = client.send_message(message)
         chunk_index = 0
-        current_task_id: str | None = task_id
 
         crewai_event_bus.emit(
             agent_branch,
             A2AStreamingStartedEvent(
                 task_id=task_id,
-                context_id=params.context_id,
-                endpoint=params.endpoint,
-                a2a_agent_name=params.a2a_agent_name,
-                turn_number=params.turn_number,
-                is_multiturn=params.is_multiturn,
-                agent_role=params.agent_role,
-                from_task=params.from_task,
-                from_agent=params.from_agent,
+                context_id=context_id,
+                endpoint=endpoint or "",
+                a2a_agent_name=a2a_agent_name,
+                turn_number=turn_number,
+                is_multiturn=is_multiturn,
+                agent_role=agent_role,
+                from_task=from_task,
+                from_agent=from_agent,
             ),
         )
 
         try:
             async for event in event_stream:
-                if isinstance(event, tuple):
-                    a2a_task, _ = event
-                    current_task_id = a2a_task.id
-
                 if isinstance(event, Message):
                     new_messages.append(event)
-                    message_context_id = event.context_id or params.context_id
+                    message_context_id = event.context_id or context_id
                     for part in event.parts:
                         if part.root.kind == "text":
                             text = part.root.text
@@ -297,12 +105,12 @@ class StreamingHandler:
                                     context_id=message_context_id,
                                     chunk=text,
                                     chunk_index=chunk_index,
-                                    endpoint=params.endpoint,
-                                    a2a_agent_name=params.a2a_agent_name,
-                                    turn_number=params.turn_number,
-                                    is_multiturn=params.is_multiturn,
-                                    from_task=params.from_task,
-                                    from_agent=params.from_agent,
+                                    endpoint=endpoint,
+                                    a2a_agent_name=a2a_agent_name,
+                                    turn_number=turn_number,
+                                    is_multiturn=is_multiturn,
+                                    from_task=from_task,
+                                    from_agent=from_agent,
                                 ),
                             )
                             chunk_index += 1
@@ -320,12 +128,12 @@ class StreamingHandler:
                         artifact_size = None
                         if artifact.parts:
                             artifact_size = sum(
-                                len(p.root.text.encode())
+                                len(p.root.text.encode("utf-8"))
                                 if p.root.kind == "text"
                                 else len(getattr(p.root, "data", b""))
                                 for p in artifact.parts
                             )
-                        effective_context_id = a2a_task.context_id or params.context_id
+                        effective_context_id = a2a_task.context_id or context_id
                         crewai_event_bus.emit(
                             agent_branch,
                             A2AArtifactReceivedEvent(
@@ -339,21 +147,29 @@ class StreamingHandler:
                                 size_bytes=artifact_size,
                                 append=update.append or False,
                                 last_chunk=update.last_chunk or False,
-                                endpoint=params.endpoint,
-                                a2a_agent_name=params.a2a_agent_name,
+                                endpoint=endpoint,
+                                a2a_agent_name=a2a_agent_name,
                                 context_id=effective_context_id,
-                                turn_number=params.turn_number,
-                                is_multiturn=params.is_multiturn,
-                                from_task=params.from_task,
-                                from_agent=params.from_agent,
+                                turn_number=turn_number,
+                                is_multiturn=is_multiturn,
+                                from_task=from_task,
+                                from_agent=from_agent,
                             ),
                         )
 
-                    is_final_update = (
-                        process_status_update(update, result_parts)
-                        if isinstance(update, TaskStatusUpdateEvent)
-                        else False
-                    )
+                    is_final_update = False
+                    if isinstance(update, TaskStatusUpdateEvent):
+                        is_final_update = update.final
+                        if (
+                            update.status
+                            and update.status.message
+                            and update.status.message.parts
+                        ):
+                            result_parts.extend(
+                                part.root.text
+                                for part in update.status.message.parts
+                                if part.root.kind == "text" and part.root.text
+                            )
 
                     if (
                         not is_final_update
@@ -366,68 +182,27 @@ class StreamingHandler:
                         a2a_task=a2a_task,
                         new_messages=new_messages,
                         agent_card=agent_card,
-                        turn_number=params.turn_number,
-                        is_multiturn=params.is_multiturn,
-                        agent_role=params.agent_role,
+                        turn_number=turn_number,
+                        is_multiturn=is_multiturn,
+                        agent_role=agent_role,
                         result_parts=result_parts,
-                        endpoint=params.endpoint,
-                        a2a_agent_name=params.a2a_agent_name,
-                        from_task=params.from_task,
-                        from_agent=params.from_agent,
+                        endpoint=endpoint,
+                        a2a_agent_name=a2a_agent_name,
+                        from_task=from_task,
+                        from_agent=from_agent,
                         is_final=is_final_update,
                     )
                     if final_result:
                         break
 
         except A2AClientHTTPError as e:
-            if current_task_id:
-                logger.info(
-                    "Stream interrupted with HTTP error, attempting recovery",
-                    extra={
-                        "task_id": current_task_id,
-                        "error": str(e),
-                        "status_code": e.status_code,
-                    },
-                )
-                recovery_kwargs = {k: v for k, v in kwargs.items() if k != "task_id"}
-                recovered_result = (
-                    await StreamingHandler._try_recover_from_interruption(
-                        client=client,
-                        task_id=current_task_id,
-                        new_messages=new_messages,
-                        agent_card=agent_card,
-                        result_parts=result_parts,
-                        **recovery_kwargs,
-                    )
-                )
-                if recovered_result:
-                    logger.info(
-                        "Successfully recovered task after HTTP error",
-                        extra={
-                            "task_id": current_task_id,
-                            "status": str(recovered_result.get("status")),
-                        },
-                    )
-                    return recovered_result
-
-                logger.warning(
-                    "Failed to recover from HTTP error, returning failure",
-                    extra={
-                        "task_id": current_task_id,
-                        "status_code": e.status_code,
-                        "original_error": str(e),
-                    },
-                )
-
             error_msg = f"HTTP Error {e.status_code}: {e!s}"
-            error_type = "http_error"
-            status_code = e.status_code
 
             error_message = Message(
                 role=Role.agent,
                 message_id=str(uuid.uuid4()),
                 parts=[Part(root=TextPart(text=error_msg))],
-                context_id=params.context_id,
+                context_id=context_id,
                 task_id=task_id,
             )
             new_messages.append(error_message)
@@ -435,118 +210,32 @@ class StreamingHandler:
             crewai_event_bus.emit(
                 agent_branch,
                 A2AConnectionErrorEvent(
-                    endpoint=params.endpoint,
+                    endpoint=endpoint or "",
                     error=str(e),
-                    error_type=error_type,
-                    status_code=status_code,
-                    a2a_agent_name=params.a2a_agent_name,
+                    error_type="http_error",
+                    status_code=e.status_code,
+                    a2a_agent_name=a2a_agent_name,
                     operation="streaming",
-                    context_id=params.context_id,
+                    context_id=context_id,
                     task_id=task_id,
-                    from_task=params.from_task,
-                    from_agent=params.from_agent,
+                    from_task=from_task,
+                    from_agent=from_agent,
                 ),
             )
             crewai_event_bus.emit(
                 agent_branch,
                 A2AResponseReceivedEvent(
                     response=error_msg,
-                    turn_number=params.turn_number,
-                    context_id=params.context_id,
-                    is_multiturn=params.is_multiturn,
+                    turn_number=turn_number,
+                    context_id=context_id,
+                    is_multiturn=is_multiturn,
                     status="failed",
                     final=True,
-                    agent_role=params.agent_role,
-                    endpoint=params.endpoint,
-                    a2a_agent_name=params.a2a_agent_name,
-                    from_task=params.from_task,
-                    from_agent=params.from_agent,
-                ),
-            )
-            return TaskStateResult(
-                status=TaskState.failed,
-                error=error_msg,
-                history=new_messages,
-            )
-
-        except (asyncio.TimeoutError, asyncio.CancelledError, ConnectionError) as e:
-            error_type = type(e).__name__.lower()
-            if current_task_id:
-                logger.info(
-                    f"Stream interrupted with {error_type}, attempting recovery",
-                    extra={"task_id": current_task_id, "error": str(e)},
-                )
-                recovery_kwargs = {k: v for k, v in kwargs.items() if k != "task_id"}
-                recovered_result = (
-                    await StreamingHandler._try_recover_from_interruption(
-                        client=client,
-                        task_id=current_task_id,
-                        new_messages=new_messages,
-                        agent_card=agent_card,
-                        result_parts=result_parts,
-                        **recovery_kwargs,
-                    )
-                )
-                if recovered_result:
-                    logger.info(
-                        f"Successfully recovered task after {error_type}",
-                        extra={
-                            "task_id": current_task_id,
-                            "status": str(recovered_result.get("status")),
-                        },
-                    )
-                    return recovered_result
-
-                logger.warning(
-                    f"Failed to recover from {error_type}, returning failure",
-                    extra={
-                        "task_id": current_task_id,
-                        "error_type": error_type,
-                        "original_error": str(e),
-                    },
-                )
-
-            error_msg = f"Connection error during streaming: {e!s}"
-            status_code = None
-
-            error_message = Message(
-                role=Role.agent,
-                message_id=str(uuid.uuid4()),
-                parts=[Part(root=TextPart(text=error_msg))],
-                context_id=params.context_id,
-                task_id=task_id,
-            )
-            new_messages.append(error_message)
-
-            crewai_event_bus.emit(
-                agent_branch,
-                A2AConnectionErrorEvent(
-                    endpoint=params.endpoint,
-                    error=str(e),
-                    error_type=error_type,
-                    status_code=status_code,
-                    a2a_agent_name=params.a2a_agent_name,
-                    operation="streaming",
-                    context_id=params.context_id,
-                    task_id=task_id,
-                    from_task=params.from_task,
-                    from_agent=params.from_agent,
-                ),
-            )
-            crewai_event_bus.emit(
-                agent_branch,
-                A2AResponseReceivedEvent(
-                    response=error_msg,
-                    turn_number=params.turn_number,
-                    context_id=params.context_id,
-                    is_multiturn=params.is_multiturn,
-                    status="failed",
-                    final=True,
-                    agent_role=params.agent_role,
-                    endpoint=params.endpoint,
-                    a2a_agent_name=params.a2a_agent_name,
-                    from_task=params.from_task,
-                    from_agent=params.from_agent,
+                    agent_role=agent_role,
+                    endpoint=endpoint,
+                    a2a_agent_name=a2a_agent_name,
+                    from_task=from_task,
+                    from_agent=from_agent,
                 ),
             )
             return TaskStateResult(
@@ -556,23 +245,13 @@ class StreamingHandler:
             )
 
         except Exception as e:
-            logger.exception(
-                "Unexpected error during streaming",
-                extra={
-                    "task_id": current_task_id,
-                    "error_type": type(e).__name__,
-                    "endpoint": params.endpoint,
-                },
-            )
-            error_msg = f"Unexpected error during streaming: {type(e).__name__}: {e!s}"
-            error_type = "unexpected_error"
-            status_code = None
+            error_msg = f"Unexpected error during streaming: {e!s}"
 
             error_message = Message(
                 role=Role.agent,
                 message_id=str(uuid.uuid4()),
                 parts=[Part(root=TextPart(text=error_msg))],
-                context_id=params.context_id,
+                context_id=context_id,
                 task_id=task_id,
             )
             new_messages.append(error_message)
@@ -580,32 +259,31 @@ class StreamingHandler:
             crewai_event_bus.emit(
                 agent_branch,
                 A2AConnectionErrorEvent(
-                    endpoint=params.endpoint,
+                    endpoint=endpoint or "",
                     error=str(e),
-                    error_type=error_type,
-                    status_code=status_code,
-                    a2a_agent_name=params.a2a_agent_name,
+                    error_type="unexpected_error",
+                    a2a_agent_name=a2a_agent_name,
                     operation="streaming",
-                    context_id=params.context_id,
+                    context_id=context_id,
                     task_id=task_id,
-                    from_task=params.from_task,
-                    from_agent=params.from_agent,
+                    from_task=from_task,
+                    from_agent=from_agent,
                 ),
             )
             crewai_event_bus.emit(
                 agent_branch,
                 A2AResponseReceivedEvent(
                     response=error_msg,
-                    turn_number=params.turn_number,
-                    context_id=params.context_id,
-                    is_multiturn=params.is_multiturn,
+                    turn_number=turn_number,
+                    context_id=context_id,
+                    is_multiturn=is_multiturn,
                     status="failed",
                     final=True,
-                    agent_role=params.agent_role,
-                    endpoint=params.endpoint,
-                    a2a_agent_name=params.a2a_agent_name,
-                    from_task=params.from_task,
-                    from_agent=params.from_agent,
+                    agent_role=agent_role,
+                    endpoint=endpoint,
+                    a2a_agent_name=a2a_agent_name,
+                    from_task=from_task,
+                    from_agent=from_agent,
                 ),
             )
             return TaskStateResult(
@@ -623,15 +301,15 @@ class StreamingHandler:
                     crewai_event_bus.emit(
                         agent_branch,
                         A2AConnectionErrorEvent(
-                            endpoint=params.endpoint,
+                            endpoint=endpoint or "",
                             error=str(close_error),
                             error_type="stream_close_error",
-                            a2a_agent_name=params.a2a_agent_name,
+                            a2a_agent_name=a2a_agent_name,
                             operation="stream_close",
-                            context_id=params.context_id,
+                            context_id=context_id,
                             task_id=task_id,
-                            from_task=params.from_task,
-                            from_agent=params.from_agent,
+                            from_task=from_task,
+                            from_agent=from_agent,
                         ),
                     )
 

lib/crewai/src/crewai/a2a/updates/streaming/params.py

@@ -1,28 +0,0 @@
-"""Common parameter extraction for streaming handlers."""
-
-from __future__ import annotations
-
-from a2a.types import TaskStatusUpdateEvent
-
-
-def process_status_update(
-    update: TaskStatusUpdateEvent,
-    result_parts: list[str],
-) -> bool:
-    """Process a status update event and extract text parts.
-
-    Args:
-        update: The status update event.
-        result_parts: List to append text parts to (modified in place).
-
-    Returns:
-        True if this is a final update, False otherwise.
-    """
-    is_final = update.final
-    if update.status and update.status.message and update.status.message.parts:
-        result_parts.extend(
-            part.root.text
-            for part in update.status.message.parts
-            if part.root.kind == "text" and part.root.text
-        )
-    return is_final

lib/crewai/src/crewai/a2a/utils/agent_card.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 import asyncio
 from collections.abc import MutableMapping
 from functools import lru_cache
-import ssl
 import time
 from types import MethodType
 from typing import TYPE_CHECKING
@@ -16,7 +15,7 @@ from aiocache import cached  # type: ignore[import-untyped]
 from aiocache.serializers import PickleSerializer  # type: ignore[import-untyped]
 import httpx
 
-from crewai.a2a.auth.client_schemes import APIKeyAuth, HTTPDigestAuth
+from crewai.a2a.auth.schemas import APIKeyAuth, HTTPDigestAuth
 from crewai.a2a.auth.utils import (
     _auth_store,
     configure_auth_client,
@@ -33,51 +32,11 @@ from crewai.events.types.a2a_events import (
 
 
 if TYPE_CHECKING:
-    from crewai.a2a.auth.client_schemes import ClientAuthScheme
+    from crewai.a2a.auth.schemas import AuthScheme
     from crewai.agent import Agent
     from crewai.task import Task
 
 
-def _get_tls_verify(auth: ClientAuthScheme | None) -> ssl.SSLContext | bool | str:
-    """Get TLS verify parameter from auth scheme.
-
-    Args:
-        auth: Optional authentication scheme with TLS config.
-
-    Returns:
-        SSL context, CA cert path, True for default verification,
-        or False if verification disabled.
-    """
-    if auth and auth.tls:
-        return auth.tls.get_httpx_ssl_context()
-    return True
-
-
-async def _prepare_auth_headers(
-    auth: ClientAuthScheme | None,
-    timeout: int,
-) -> tuple[MutableMapping[str, str], ssl.SSLContext | bool | str]:
-    """Prepare authentication headers and TLS verification settings.
-
-    Args:
-        auth: Optional authentication scheme.
-        timeout: Request timeout in seconds.
-
-    Returns:
-        Tuple of (headers dict, TLS verify setting).
-    """
-    headers: MutableMapping[str, str] = {}
-    verify = _get_tls_verify(auth)
-    if auth:
-        async with httpx.AsyncClient(
-            timeout=timeout, verify=verify
-        ) as temp_auth_client:
-            if isinstance(auth, (HTTPDigestAuth, APIKeyAuth)):
-                configure_auth_client(auth, temp_auth_client)
-            headers = await auth.apply_auth(temp_auth_client, {})
-    return headers, verify
-
-
 def _get_server_config(agent: Agent) -> A2AServerConfig | None:
     """Get A2AServerConfig from an agent's a2a configuration.
 
@@ -100,7 +59,7 @@ def _get_server_config(agent: Agent) -> A2AServerConfig | None:
 
 def fetch_agent_card(
     endpoint: str,
-    auth: ClientAuthScheme | None = None,
+    auth: AuthScheme | None = None,
     timeout: int = 30,
     use_cache: bool = True,
     cache_ttl: int = 300,
@@ -109,7 +68,7 @@ def fetch_agent_card(
 
     Args:
         endpoint: A2A agent endpoint URL (AgentCard URL).
-        auth: Optional ClientAuthScheme for authentication.
+        auth: Optional AuthScheme for authentication.
         timeout: Request timeout in seconds.
         use_cache: Whether to use caching (default True).
         cache_ttl: Cache TTL in seconds (default 300 = 5 minutes).
@@ -131,10 +90,10 @@ def fetch_agent_card(
                     "_authorization_callback",
                 }
             )
-            auth_hash = _auth_store.compute_key(type(auth).__name__, auth_data)
+            auth_hash = hash((type(auth).__name__, auth_data))
         else:
-            auth_hash = _auth_store.compute_key("none", "")
-        _auth_store.set(auth_hash, auth)
+            auth_hash = 0
+        _auth_store[auth_hash] = auth
         ttl_hash = int(time.time() // cache_ttl)
         return _fetch_agent_card_cached(endpoint, auth_hash, timeout, ttl_hash)
 
@@ -150,7 +109,7 @@ def fetch_agent_card(
 
 async def afetch_agent_card(
     endpoint: str,
-    auth: ClientAuthScheme | None = None,
+    auth: AuthScheme | None = None,
     timeout: int = 30,
     use_cache: bool = True,
 ) -> AgentCard:
@@ -160,7 +119,7 @@ async def afetch_agent_card(
 
     Args:
         endpoint: A2A agent endpoint URL (AgentCard URL).
-        auth: Optional ClientAuthScheme for authentication.
+        auth: Optional AuthScheme for authentication.
         timeout: Request timeout in seconds.
         use_cache: Whether to use caching (default True).
 
@@ -181,10 +140,10 @@ async def afetch_agent_card(
                     "_authorization_callback",
                 }
             )
-            auth_hash = _auth_store.compute_key(type(auth).__name__, auth_data)
+            auth_hash = hash((type(auth).__name__, auth_data))
         else:
-            auth_hash = _auth_store.compute_key("none", "")
-        _auth_store.set(auth_hash, auth)
+            auth_hash = 0
+        _auth_store[auth_hash] = auth
         agent_card: AgentCard = await _afetch_agent_card_cached(
             endpoint, auth_hash, timeout
         )
@@ -196,7 +155,7 @@ async def afetch_agent_card(
 @lru_cache()
 def _fetch_agent_card_cached(
     endpoint: str,
-    auth_hash: str,
+    auth_hash: int,
     timeout: int,
     _ttl_hash: int,
 ) -> AgentCard:
@@ -216,7 +175,7 @@ def _fetch_agent_card_cached(
 @cached(ttl=300, serializer=PickleSerializer())  # type: ignore[untyped-decorator]
 async def _afetch_agent_card_cached(
     endpoint: str,
-    auth_hash: str,
+    auth_hash: int,
     timeout: int,
 ) -> AgentCard:
     """Cached async implementation of AgentCard fetching."""
@@ -226,7 +185,7 @@ async def _afetch_agent_card_cached(
 
 async def _afetch_agent_card_impl(
     endpoint: str,
-    auth: ClientAuthScheme | None,
+    auth: AuthScheme | None,
     timeout: int,
 ) -> AgentCard:
     """Internal async implementation of AgentCard fetching."""
@@ -238,17 +197,16 @@ async def _afetch_agent_card_impl(
     else:
         url_parts = endpoint.split("/", 3)
         base_url = f"{url_parts[0]}//{url_parts[2]}"
-        agent_card_path = (
-            f"/{url_parts[3]}"
-            if len(url_parts) > 3 and url_parts[3]
-            else "/.well-known/agent-card.json"
-        )
+        agent_card_path = f"/{url_parts[3]}" if len(url_parts) > 3 else "/"
 
-    headers, verify = await _prepare_auth_headers(auth, timeout)
+    headers: MutableMapping[str, str] = {}
+    if auth:
+        async with httpx.AsyncClient(timeout=timeout) as temp_auth_client:
+            if isinstance(auth, (HTTPDigestAuth, APIKeyAuth)):
+                configure_auth_client(auth, temp_auth_client)
+            headers = await auth.apply_auth(temp_auth_client, {})
 
-    async with httpx.AsyncClient(
-        timeout=timeout, headers=headers, verify=verify
-    ) as temp_client:
+    async with httpx.AsyncClient(timeout=timeout, headers=headers) as temp_client:
         if auth and isinstance(auth, (HTTPDigestAuth, APIKeyAuth)):
             configure_auth_client(auth, temp_client)
 
@@ -476,7 +434,6 @@ def _agent_to_agent_card(agent: Agent, url: str) -> AgentCard:
     """Generate an A2A AgentCard from an Agent instance.
 
     Uses A2AServerConfig values when available, falling back to agent properties.
-    If signing_config is provided, the card will be signed with JWS.
 
     Args:
         agent: The Agent instance to generate a card for.
@@ -485,8 +442,6 @@ def _agent_to_agent_card(agent: Agent, url: str) -> AgentCard:
     Returns:
         AgentCard describing the agent's capabilities.
     """
-    from crewai.a2a.utils.agent_card_signing import sign_agent_card
-
     server_config = _get_server_config(agent) or A2AServerConfig()
 
     name = server_config.name or agent.role
@@ -517,31 +472,15 @@ def _agent_to_agent_card(agent: Agent, url: str) -> AgentCard:
                 )
             )
 
-    capabilities = server_config.capabilities
-    if server_config.server_extensions:
-        from crewai.a2a.extensions.server import ServerExtensionRegistry
-
-        registry = ServerExtensionRegistry(server_config.server_extensions)
-        ext_list = registry.get_agent_extensions()
-
-        existing_exts = list(capabilities.extensions) if capabilities.extensions else []
-        existing_uris = {e.uri for e in existing_exts}
-        for ext in ext_list:
-            if ext.uri not in existing_uris:
-                existing_exts.append(ext)
-
-        capabilities = capabilities.model_copy(update={"extensions": existing_exts})
-
-    card = AgentCard(
+    return AgentCard(
         name=name,
         description=description,
         url=server_config.url or url,
         version=server_config.version,
-        capabilities=capabilities,
+        capabilities=server_config.capabilities,
         default_input_modes=server_config.default_input_modes,
         default_output_modes=server_config.default_output_modes,
         skills=skills,
-        preferred_transport=server_config.transport.preferred,
         protocol_version=server_config.protocol_version,
         provider=server_config.provider,
         documentation_url=server_config.documentation_url,
@@ -550,21 +489,9 @@ def _agent_to_agent_card(agent: Agent, url: str) -> AgentCard:
         security=server_config.security,
         security_schemes=server_config.security_schemes,
         supports_authenticated_extended_card=server_config.supports_authenticated_extended_card,
+        signatures=server_config.signatures,
     )
 
-    if server_config.signing_config:
-        signature = sign_agent_card(
-            card,
-            private_key=server_config.signing_config.get_private_key(),
-            key_id=server_config.signing_config.key_id,
-            algorithm=server_config.signing_config.algorithm,
-        )
-        card = card.model_copy(update={"signatures": [signature]})
-    elif server_config.signatures:
-        card = card.model_copy(update={"signatures": server_config.signatures})
-
-    return card
-
 
 def inject_a2a_server_methods(agent: Agent) -> None:
     """Inject A2A server methods onto an Agent instance.

lib/crewai/src/crewai/a2a/utils/agent_card_signing.py

@@ -1,236 +0,0 @@
-"""AgentCard JWS signing utilities.
-
-This module provides functions for signing and verifying AgentCards using
-JSON Web Signatures (JWS) as per RFC 7515. Signed agent cards allow clients
-to verify the authenticity and integrity of agent card information.
-
-Example:
-    >>> from crewai.a2a.utils.agent_card_signing import sign_agent_card
-    >>> signature = sign_agent_card(agent_card, private_key_pem, key_id="key-1")
-    >>> card_with_sig = card.model_copy(update={"signatures": [signature]})
-"""
-
-from __future__ import annotations
-
-import base64
-import json
-import logging
-from typing import Any, Literal
-
-from a2a.types import AgentCard, AgentCardSignature
-import jwt
-from pydantic import SecretStr
-
-
-logger = logging.getLogger(__name__)
-
-
-SigningAlgorithm = Literal[
-    "RS256", "RS384", "RS512", "ES256", "ES384", "ES512", "PS256", "PS384", "PS512"
-]
-
-
-def _normalize_private_key(private_key: str | bytes | SecretStr) -> bytes:
-    """Normalize private key to bytes format.
-
-    Args:
-        private_key: PEM-encoded private key as string, bytes, or SecretStr.
-
-    Returns:
-        Private key as bytes.
-    """
-    if isinstance(private_key, SecretStr):
-        private_key = private_key.get_secret_value()
-    if isinstance(private_key, str):
-        private_key = private_key.encode()
-    return private_key
-
-
-def _serialize_agent_card(agent_card: AgentCard) -> str:
-    """Serialize AgentCard to canonical JSON for signing.
-
-    Excludes the signatures field to avoid circular reference during signing.
-    Uses sorted keys and compact separators for deterministic output.
-
-    Args:
-        agent_card: The AgentCard to serialize.
-
-    Returns:
-        Canonical JSON string representation.
-    """
-    card_dict = agent_card.model_dump(exclude={"signatures"}, exclude_none=True)
-    return json.dumps(card_dict, sort_keys=True, separators=(",", ":"))
-
-
-def _base64url_encode(data: bytes | str) -> str:
-    """Encode data to URL-safe base64 without padding.
-
-    Args:
-        data: Data to encode.
-
-    Returns:
-        URL-safe base64 encoded string without padding.
-    """
-    if isinstance(data, str):
-        data = data.encode()
-    return base64.urlsafe_b64encode(data).rstrip(b"=").decode("ascii")
-
-
-def sign_agent_card(
-    agent_card: AgentCard,
-    private_key: str | bytes | SecretStr,
-    key_id: str | None = None,
-    algorithm: SigningAlgorithm = "RS256",
-) -> AgentCardSignature:
-    """Sign an AgentCard using JWS (RFC 7515).
-
-    Creates a detached JWS signature for the AgentCard. The signature covers
-    all fields except the signatures field itself.
-
-    Args:
-        agent_card: The AgentCard to sign.
-        private_key: PEM-encoded private key (RSA, EC, or RSA-PSS).
-        key_id: Optional key identifier for the JWS header (kid claim).
-        algorithm: Signing algorithm (RS256, ES256, PS256, etc.).
-
-    Returns:
-        AgentCardSignature with protected header and signature.
-
-    Raises:
-        jwt.exceptions.InvalidKeyError: If the private key is invalid.
-        ValueError: If the algorithm is not supported for the key type.
-
-    Example:
-        >>> signature = sign_agent_card(
-        ...     agent_card,
-        ...     private_key_pem="-----BEGIN PRIVATE KEY-----...",
-        ...     key_id="my-key-id",
-        ... )
-    """
-    key_bytes = _normalize_private_key(private_key)
-    payload = _serialize_agent_card(agent_card)
-
-    protected_header: dict[str, Any] = {"typ": "JWS"}
-    if key_id:
-        protected_header["kid"] = key_id
-
-    jws_token = jwt.api_jws.encode(
-        payload.encode(),
-        key_bytes,
-        algorithm=algorithm,
-        headers=protected_header,
-    )
-
-    parts = jws_token.split(".")
-    protected_b64 = parts[0]
-    signature_b64 = parts[2]
-
-    header: dict[str, Any] | None = None
-    if key_id:
-        header = {"kid": key_id}
-
-    return AgentCardSignature(
-        protected=protected_b64,
-        signature=signature_b64,
-        header=header,
-    )
-
-
-def verify_agent_card_signature(
-    agent_card: AgentCard,
-    signature: AgentCardSignature,
-    public_key: str | bytes,
-    algorithms: list[str] | None = None,
-) -> bool:
-    """Verify an AgentCard JWS signature.
-
-    Validates that the signature was created with the corresponding private key
-    and that the AgentCard content has not been modified.
-
-    Args:
-        agent_card: The AgentCard to verify.
-        signature: The AgentCardSignature to validate.
-        public_key: PEM-encoded public key (RSA, EC, or RSA-PSS).
-        algorithms: List of allowed algorithms. Defaults to common asymmetric algorithms.
-
-    Returns:
-        True if signature is valid, False otherwise.
-
-    Example:
-        >>> is_valid = verify_agent_card_signature(
-        ...     agent_card, signature, public_key_pem="-----BEGIN PUBLIC KEY-----..."
-        ... )
-    """
-    if algorithms is None:
-        algorithms = [
-            "RS256",
-            "RS384",
-            "RS512",
-            "ES256",
-            "ES384",
-            "ES512",
-            "PS256",
-            "PS384",
-            "PS512",
-        ]
-
-    if isinstance(public_key, str):
-        public_key = public_key.encode()
-
-    payload = _serialize_agent_card(agent_card)
-    payload_b64 = _base64url_encode(payload)
-    jws_token = f"{signature.protected}.{payload_b64}.{signature.signature}"
-
-    try:
-        jwt.api_jws.decode(
-            jws_token,
-            public_key,
-            algorithms=algorithms,
-        )
-        return True
-    except jwt.InvalidSignatureError:
-        logger.debug(
-            "AgentCard signature verification failed",
-            extra={"reason": "invalid_signature"},
-        )
-        return False
-    except jwt.DecodeError as e:
-        logger.debug(
-            "AgentCard signature verification failed",
-            extra={"reason": "decode_error", "error": str(e)},
-        )
-        return False
-    except jwt.InvalidAlgorithmError as e:
-        logger.debug(
-            "AgentCard signature verification failed",
-            extra={"reason": "algorithm_error", "error": str(e)},
-        )
-        return False
-
-
-def get_key_id_from_signature(signature: AgentCardSignature) -> str | None:
-    """Extract the key ID (kid) from an AgentCardSignature.
-
-    Checks both the unprotected header and the protected header for the kid claim.
-
-    Args:
-        signature: The AgentCardSignature to extract from.
-
-    Returns:
-        The key ID if present, None otherwise.
-    """
-    if signature.header and "kid" in signature.header:
-        kid: str = signature.header["kid"]
-        return kid
-
-    try:
-        protected = signature.protected
-        padding_needed = 4 - (len(protected) % 4)
-        if padding_needed != 4:
-            protected += "=" * padding_needed
-
-        protected_json = base64.urlsafe_b64decode(protected).decode()
-        protected_header: dict[str, Any] = json.loads(protected_json)
-        return protected_header.get("kid")
-    except (ValueError, json.JSONDecodeError):
-        return None

lib/crewai/src/crewai/a2a/utils/content_type.py

@@ -1,339 +0,0 @@
-"""Content type negotiation for A2A protocol.
-
-This module handles negotiation of input/output MIME types between A2A clients
-and servers based on AgentCard capabilities.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Annotated, Final, Literal, cast
-
-from a2a.types import Part
-
-from crewai.events.event_bus import crewai_event_bus
-from crewai.events.types.a2a_events import A2AContentTypeNegotiatedEvent
-
-
-if TYPE_CHECKING:
-    from a2a.types import AgentCard, AgentSkill
-
-
-TEXT_PLAIN: Literal["text/plain"] = "text/plain"
-APPLICATION_JSON: Literal["application/json"] = "application/json"
-IMAGE_PNG: Literal["image/png"] = "image/png"
-IMAGE_JPEG: Literal["image/jpeg"] = "image/jpeg"
-IMAGE_WILDCARD: Literal["image/*"] = "image/*"
-APPLICATION_PDF: Literal["application/pdf"] = "application/pdf"
-APPLICATION_OCTET_STREAM: Literal["application/octet-stream"] = (
-    "application/octet-stream"
-)
-
-DEFAULT_CLIENT_INPUT_MODES: Final[list[Literal["text/plain", "application/json"]]] = [
-    TEXT_PLAIN,
-    APPLICATION_JSON,
-]
-DEFAULT_CLIENT_OUTPUT_MODES: Final[list[Literal["text/plain", "application/json"]]] = [
-    TEXT_PLAIN,
-    APPLICATION_JSON,
-]
-
-
-@dataclass
-class NegotiatedContentTypes:
-    """Result of content type negotiation."""
-
-    input_modes: Annotated[list[str], "Negotiated input MIME types the client can send"]
-    output_modes: Annotated[
-        list[str], "Negotiated output MIME types the server will produce"
-    ]
-    effective_input_modes: Annotated[list[str], "Server's effective input modes"]
-    effective_output_modes: Annotated[list[str], "Server's effective output modes"]
-    skill_name: Annotated[
-        str | None, "Skill name if negotiation was skill-specific"
-    ] = None
-
-
-class ContentTypeNegotiationError(Exception):
-    """Raised when no compatible content types can be negotiated."""
-
-    def __init__(
-        self,
-        client_input_modes: list[str],
-        client_output_modes: list[str],
-        server_input_modes: list[str],
-        server_output_modes: list[str],
-        direction: str = "both",
-        message: str | None = None,
-    ) -> None:
-        self.client_input_modes = client_input_modes
-        self.client_output_modes = client_output_modes
-        self.server_input_modes = server_input_modes
-        self.server_output_modes = server_output_modes
-        self.direction = direction
-
-        if message is None:
-            if direction == "input":
-                message = (
-                    f"No compatible input content types. "
-                    f"Client supports: {client_input_modes}, "
-                    f"Server accepts: {server_input_modes}"
-                )
-            elif direction == "output":
-                message = (
-                    f"No compatible output content types. "
-                    f"Client accepts: {client_output_modes}, "
-                    f"Server produces: {server_output_modes}"
-                )
-            else:
-                message = (
-                    f"No compatible content types. "
-                    f"Input - Client: {client_input_modes}, Server: {server_input_modes}. "
-                    f"Output - Client: {client_output_modes}, Server: {server_output_modes}"
-                )
-
-        super().__init__(message)
-
-
-def _normalize_mime_type(mime_type: str) -> str:
-    """Normalize MIME type for comparison (lowercase, strip whitespace)."""
-    return mime_type.lower().strip()
-
-
-def _mime_types_compatible(client_type: str, server_type: str) -> bool:
-    """Check if two MIME types are compatible.
-
-    Handles wildcards like image/* matching image/png.
-    """
-    client_normalized = _normalize_mime_type(client_type)
-    server_normalized = _normalize_mime_type(server_type)
-
-    if client_normalized == server_normalized:
-        return True
-
-    if "*" in client_normalized or "*" in server_normalized:
-        client_parts = client_normalized.split("/")
-        server_parts = server_normalized.split("/")
-
-        if len(client_parts) == 2 and len(server_parts) == 2:
-            type_match = (
-                client_parts[0] == server_parts[0]
-                or client_parts[0] == "*"
-                or server_parts[0] == "*"
-            )
-            subtype_match = (
-                client_parts[1] == server_parts[1]
-                or client_parts[1] == "*"
-                or server_parts[1] == "*"
-            )
-            return type_match and subtype_match
-
-    return False
-
-
-def _find_compatible_modes(
-    client_modes: list[str], server_modes: list[str]
-) -> list[str]:
-    """Find compatible MIME types between client and server.
-
-    Returns modes in client preference order.
-    """
-    compatible = []
-    for client_mode in client_modes:
-        for server_mode in server_modes:
-            if _mime_types_compatible(client_mode, server_mode):
-                if "*" in client_mode and "*" not in server_mode:
-                    if server_mode not in compatible:
-                        compatible.append(server_mode)
-                else:
-                    if client_mode not in compatible:
-                        compatible.append(client_mode)
-                break
-    return compatible
-
-
-def _get_effective_modes(
-    agent_card: AgentCard,
-    skill_name: str | None = None,
-) -> tuple[list[str], list[str], AgentSkill | None]:
-    """Get effective input/output modes from agent card.
-
-    If skill_name is provided and the skill has custom modes, those are used.
-    Otherwise, falls back to agent card defaults.
-    """
-    skill: AgentSkill | None = None
-
-    if skill_name and agent_card.skills:
-        for s in agent_card.skills:
-            if s.name == skill_name or s.id == skill_name:
-                skill = s
-                break
-
-    if skill:
-        input_modes = (
-            skill.input_modes if skill.input_modes else agent_card.default_input_modes
-        )
-        output_modes = (
-            skill.output_modes
-            if skill.output_modes
-            else agent_card.default_output_modes
-        )
-    else:
-        input_modes = agent_card.default_input_modes
-        output_modes = agent_card.default_output_modes
-
-    return input_modes, output_modes, skill
-
-
-def negotiate_content_types(
-    agent_card: AgentCard,
-    client_input_modes: list[str] | None = None,
-    client_output_modes: list[str] | None = None,
-    skill_name: str | None = None,
-    emit_event: bool = True,
-    endpoint: str | None = None,
-    a2a_agent_name: str | None = None,
-    strict: bool = False,
-) -> NegotiatedContentTypes:
-    """Negotiate content types between client and server.
-
-    Args:
-        agent_card: The remote agent's card with capability info.
-        client_input_modes: MIME types the client can send. Defaults to text/plain and application/json.
-        client_output_modes: MIME types the client can accept. Defaults to text/plain and application/json.
-        skill_name: Optional skill to use for mode lookup.
-        emit_event: Whether to emit a content type negotiation event.
-        endpoint: Agent endpoint (for event metadata).
-        a2a_agent_name: Agent name (for event metadata).
-        strict: If True, raises error when no compatible types found.
-            If False, returns empty lists for incompatible directions.
-
-    Returns:
-        NegotiatedContentTypes with compatible input and output modes.
-
-    Raises:
-        ContentTypeNegotiationError: If strict=True and no compatible types found.
-    """
-    if client_input_modes is None:
-        client_input_modes = cast(list[str], DEFAULT_CLIENT_INPUT_MODES.copy())
-    if client_output_modes is None:
-        client_output_modes = cast(list[str], DEFAULT_CLIENT_OUTPUT_MODES.copy())
-
-    server_input_modes, server_output_modes, skill = _get_effective_modes(
-        agent_card, skill_name
-    )
-
-    compatible_input = _find_compatible_modes(client_input_modes, server_input_modes)
-    compatible_output = _find_compatible_modes(client_output_modes, server_output_modes)
-
-    if strict:
-        if not compatible_input and not compatible_output:
-            raise ContentTypeNegotiationError(
-                client_input_modes=client_input_modes,
-                client_output_modes=client_output_modes,
-                server_input_modes=server_input_modes,
-                server_output_modes=server_output_modes,
-            )
-        if not compatible_input:
-            raise ContentTypeNegotiationError(
-                client_input_modes=client_input_modes,
-                client_output_modes=client_output_modes,
-                server_input_modes=server_input_modes,
-                server_output_modes=server_output_modes,
-                direction="input",
-            )
-        if not compatible_output:
-            raise ContentTypeNegotiationError(
-                client_input_modes=client_input_modes,
-                client_output_modes=client_output_modes,
-                server_input_modes=server_input_modes,
-                server_output_modes=server_output_modes,
-                direction="output",
-            )
-
-    result = NegotiatedContentTypes(
-        input_modes=compatible_input,
-        output_modes=compatible_output,
-        effective_input_modes=server_input_modes,
-        effective_output_modes=server_output_modes,
-        skill_name=skill.name if skill else None,
-    )
-
-    if emit_event:
-        crewai_event_bus.emit(
-            None,
-            A2AContentTypeNegotiatedEvent(
-                endpoint=endpoint or agent_card.url,
-                a2a_agent_name=a2a_agent_name or agent_card.name,
-                skill_name=skill_name,
-                client_input_modes=client_input_modes,
-                client_output_modes=client_output_modes,
-                server_input_modes=server_input_modes,
-                server_output_modes=server_output_modes,
-                negotiated_input_modes=compatible_input,
-                negotiated_output_modes=compatible_output,
-                negotiation_success=bool(compatible_input and compatible_output),
-            ),
-        )
-
-    return result
-
-
-def validate_content_type(
-    content_type: str,
-    allowed_modes: list[str],
-) -> bool:
-    """Validate that a content type is allowed by a list of modes.
-
-    Args:
-        content_type: The MIME type to validate.
-        allowed_modes: List of allowed MIME types (may include wildcards).
-
-    Returns:
-        True if content_type is compatible with any allowed mode.
-    """
-    for mode in allowed_modes:
-        if _mime_types_compatible(content_type, mode):
-            return True
-    return False
-
-
-def get_part_content_type(part: Part) -> str:
-    """Extract MIME type from an A2A Part.
-
-    Args:
-        part: A Part object containing TextPart, DataPart, or FilePart.
-
-    Returns:
-        The MIME type string for this part.
-    """
-    root = part.root
-    if root.kind == "text":
-        return TEXT_PLAIN
-    if root.kind == "data":
-        return APPLICATION_JSON
-    if root.kind == "file":
-        return root.file.mime_type or APPLICATION_OCTET_STREAM
-    return APPLICATION_OCTET_STREAM
-
-
-def validate_message_parts(
-    parts: list[Part],
-    allowed_modes: list[str],
-) -> list[str]:
-    """Validate that all message parts have allowed content types.
-
-    Args:
-        parts: List of Parts from the incoming message.
-        allowed_modes: List of allowed MIME types (from default_input_modes).
-
-    Returns:
-        List of invalid content types found (empty if all valid).
-    """
-    invalid_types: list[str] = []
-    for part in parts:
-        content_type = get_part_content_type(part)
-        if not validate_content_type(content_type, allowed_modes):
-            if content_type not in invalid_types:
-                invalid_types.append(content_type)
-    return invalid_types

lib/crewai/src/crewai/a2a/utils/delegation.py

@@ -3,18 +3,14 @@
 from __future__ import annotations
 
 import asyncio
-import base64
-from collections.abc import AsyncIterator, Callable, MutableMapping
+from collections.abc import AsyncIterator, MutableMapping
 from contextlib import asynccontextmanager
-import logging
-from typing import TYPE_CHECKING, Any, Final, Literal
+from typing import TYPE_CHECKING, Any, Literal
 import uuid
 
 from a2a.client import Client, ClientConfig, ClientFactory
 from a2a.types import (
     AgentCard,
-    FilePart,
-    FileWithBytes,
     Message,
     Part,
     PushNotificationConfig as A2APushNotificationConfig,
@@ -24,24 +20,18 @@ from a2a.types import (
 import httpx
 from pydantic import BaseModel
 
-from crewai.a2a.auth.client_schemes import APIKeyAuth, HTTPDigestAuth
+from crewai.a2a.auth.schemas import APIKeyAuth, HTTPDigestAuth
 from crewai.a2a.auth.utils import (
     _auth_store,
     configure_auth_client,
     validate_auth_against_agent_card,
 )
-from crewai.a2a.config import ClientTransportConfig, GRPCClientConfig
-from crewai.a2a.extensions.registry import (
-    ExtensionsMiddleware,
-    validate_required_extensions,
-)
 from crewai.a2a.task_helpers import TaskStateResult
 from crewai.a2a.types import (
     HANDLER_REGISTRY,
     HandlerType,
     PartsDict,
     PartsMetadataDict,
-    TransportType,
 )
 from crewai.a2a.updates import (
     PollingConfig,
@@ -49,20 +39,7 @@ from crewai.a2a.updates import (
     StreamingHandler,
     UpdateConfig,
 )
-from crewai.a2a.utils.agent_card import (
-    _afetch_agent_card_cached,
-    _get_tls_verify,
-    _prepare_auth_headers,
-)
-from crewai.a2a.utils.content_type import (
-    DEFAULT_CLIENT_OUTPUT_MODES,
-    negotiate_content_types,
-)
-from crewai.a2a.utils.transport import (
-    NegotiatedTransport,
-    TransportNegotiationError,
-    negotiate_transport,
-)
+from crewai.a2a.utils.agent_card import _afetch_agent_card_cached
 from crewai.events.event_bus import crewai_event_bus
 from crewai.events.types.a2a_events import (
     A2AConversationStartedEvent,
@@ -72,48 +49,10 @@ from crewai.events.types.a2a_events import (
 )
 
 
-logger = logging.getLogger(__name__)
-
-
 if TYPE_CHECKING:
     from a2a.types import Message
 
-    from crewai.a2a.auth.client_schemes import ClientAuthScheme
-
-
-_DEFAULT_TRANSPORT: Final[TransportType] = "JSONRPC"
-
-
-def _create_file_parts(input_files: dict[str, Any] | None) -> list[Part]:
-    """Convert FileInput dictionary to FilePart objects.
-
-    Args:
-        input_files: Dictionary mapping names to FileInput objects.
-
-    Returns:
-        List of Part objects containing FilePart data.
-    """
-    if not input_files:
-        return []
-
-    try:
-        import crewai_files  # noqa: F401
-    except ImportError:
-        logger.debug("crewai_files not installed, skipping file parts")
-        return []
-
-    parts: list[Part] = []
-    for name, file_input in input_files.items():
-        content_bytes = file_input.read()
-        content_base64 = base64.b64encode(content_bytes).decode()
-        file_with_bytes = FileWithBytes(
-            bytes=content_base64,
-            mimeType=file_input.content_type,
-            name=file_input.filename or name,
-        )
-        parts.append(Part(root=FilePart(file=file_with_bytes)))
-
-    return parts
+    from crewai.a2a.auth.schemas import AuthScheme
 
 
 def get_handler(config: UpdateConfig | None) -> HandlerType:
@@ -132,7 +71,8 @@ def get_handler(config: UpdateConfig | None) -> HandlerType:
 
 def execute_a2a_delegation(
     endpoint: str,
-    auth: ClientAuthScheme | None,
+    transport_protocol: Literal["JSONRPC", "GRPC", "HTTP+JSON"],
+    auth: AuthScheme | None,
     timeout: int,
     task_description: str,
     context: str | None = None,
@@ -151,24 +91,32 @@ def execute_a2a_delegation(
     from_task: Any | None = None,
     from_agent: Any | None = None,
     skill_id: str | None = None,
-    client_extensions: list[str] | None = None,
-    transport: ClientTransportConfig | None = None,
-    accepted_output_modes: list[str] | None = None,
-    input_files: dict[str, Any] | None = None,
 ) -> TaskStateResult:
     """Execute a task delegation to a remote A2A agent synchronously.
 
-    WARNING: This function blocks the entire thread by creating and running a new
-    event loop. Prefer using 'await aexecute_a2a_delegation()' in async contexts
-    for better performance and resource efficiency.
-
-    This is a synchronous wrapper around aexecute_a2a_delegation that creates a
-    new event loop to run the async implementation. It is provided for compatibility
-    with synchronous code paths only.
+    This is the sync wrapper around aexecute_a2a_delegation. For async contexts,
+    use aexecute_a2a_delegation directly.
 
     Args:
-        endpoint: A2A agent endpoint URL (AgentCard URL).
-        auth: Optional ClientAuthScheme for authentication.
+        endpoint: A2A agent endpoint URL (AgentCard URL)
+        transport_protocol: Optional A2A transport protocol (grpc, jsonrpc, http+json)
+        auth: Optional AuthScheme for authentication (Bearer, OAuth2, API Key, HTTP Basic/Digest)
+        timeout: Request timeout in seconds
+        task_description: The task to delegate
+        context: Optional context information
+        context_id: Context ID for correlating messages/tasks
+        task_id: Specific task identifier
+        reference_task_ids: List of related task IDs
+        metadata: Additional metadata (external_id, request_id, etc.)
+        extensions: Protocol extensions for custom fields
+        conversation_history: Previous Message objects from conversation
+        agent_id: Agent identifier for logging
+        agent_role: Role of the CrewAI agent delegating the task
+        agent_branch: Optional agent tree branch for logging
+        response_model: Optional Pydantic model for structured outputs
+        turn_number: Optional turn number for multi-turn conversations
+        endpoint: A2A agent endpoint URL.
+        auth: Optional AuthScheme for authentication.
         timeout: Request timeout in seconds.
         task_description: The task to delegate.
         context: Optional context information.
@@ -187,27 +135,10 @@ def execute_a2a_delegation(
         from_task: Optional CrewAI Task object for event metadata.
         from_agent: Optional CrewAI Agent object for event metadata.
         skill_id: Optional skill ID to target a specific agent capability.
-        client_extensions: A2A protocol extension URIs the client supports.
-        transport: Transport configuration (preferred, supported transports, gRPC settings).
-        accepted_output_modes: MIME types the client can accept in responses.
-        input_files: Optional dictionary of files to send to remote agent.
 
     Returns:
         TaskStateResult with status, result/error, history, and agent_card.
-
-    Raises:
-        RuntimeError: If called from an async context with a running event loop.
     """
-    try:
-        asyncio.get_running_loop()
-        raise RuntimeError(
-            "execute_a2a_delegation() cannot be called from an async context. "
-            "Use 'await aexecute_a2a_delegation()' instead."
-        )
-    except RuntimeError as e:
-        if "no running event loop" not in str(e).lower():
-            raise
-
     loop = asyncio.new_event_loop()
     asyncio.set_event_loop(loop)
     try:
@@ -228,15 +159,12 @@ def execute_a2a_delegation(
                 agent_role=agent_role,
                 agent_branch=agent_branch,
                 response_model=response_model,
+                transport_protocol=transport_protocol,
                 turn_number=turn_number,
                 updates=updates,
                 from_task=from_task,
                 from_agent=from_agent,
                 skill_id=skill_id,
-                client_extensions=client_extensions,
-                transport=transport,
-                accepted_output_modes=accepted_output_modes,
-                input_files=input_files,
             )
         )
     finally:
@@ -248,7 +176,8 @@ def execute_a2a_delegation(
 
 async def aexecute_a2a_delegation(
     endpoint: str,
-    auth: ClientAuthScheme | None,
+    transport_protocol: Literal["JSONRPC", "GRPC", "HTTP+JSON"],
+    auth: AuthScheme | None,
     timeout: int,
     task_description: str,
     context: str | None = None,
@@ -267,10 +196,6 @@ async def aexecute_a2a_delegation(
     from_task: Any | None = None,
     from_agent: Any | None = None,
     skill_id: str | None = None,
-    client_extensions: list[str] | None = None,
-    transport: ClientTransportConfig | None = None,
-    accepted_output_modes: list[str] | None = None,
-    input_files: dict[str, Any] | None = None,
 ) -> TaskStateResult:
     """Execute a task delegation to a remote A2A agent asynchronously.
 
@@ -278,8 +203,25 @@ async def aexecute_a2a_delegation(
     in an async context (e.g., with Crew.akickoff() or agent.aexecute_task()).
 
     Args:
+        endpoint: A2A agent endpoint URL
+        transport_protocol: Optional A2A transport protocol (grpc, jsonrpc, http+json)
+        auth: Optional AuthScheme for authentication
+        timeout: Request timeout in seconds
+        task_description: Task to delegate
+        context: Optional context
+        context_id: Context ID for correlation
+        task_id: Specific task identifier
+        reference_task_ids: Related task IDs
+        metadata: Additional metadata
+        extensions: Protocol extensions
+        conversation_history: Previous Message objects
+        turn_number: Current turn number
+        agent_branch: Agent tree branch for logging
+        agent_id: Agent identifier for logging
+        agent_role: Agent role for logging
+        response_model: Optional Pydantic model for structured outputs
         endpoint: A2A agent endpoint URL.
-        auth: Optional ClientAuthScheme for authentication.
+        auth: Optional AuthScheme for authentication.
         timeout: Request timeout in seconds.
         task_description: The task to delegate.
         context: Optional context information.
@@ -298,10 +240,6 @@ async def aexecute_a2a_delegation(
         from_task: Optional CrewAI Task object for event metadata.
         from_agent: Optional CrewAI Agent object for event metadata.
         skill_id: Optional skill ID to target a specific agent capability.
-        client_extensions: A2A protocol extension URIs the client supports.
-        transport: Transport configuration (preferred, supported transports, gRPC settings).
-        accepted_output_modes: MIME types the client can accept in responses.
-        input_files: Optional dictionary of files to send to remote agent.
 
     Returns:
         TaskStateResult with status, result/error, history, and agent_card.
@@ -333,13 +271,10 @@ async def aexecute_a2a_delegation(
             agent_role=agent_role,
             response_model=response_model,
             updates=updates,
+            transport_protocol=transport_protocol,
             from_task=from_task,
             from_agent=from_agent,
             skill_id=skill_id,
-            client_extensions=client_extensions,
-            transport=transport,
-            accepted_output_modes=accepted_output_modes,
-            input_files=input_files,
         )
     except Exception as e:
         crewai_event_bus.emit(
@@ -359,7 +294,7 @@ async def aexecute_a2a_delegation(
         )
         raise
 
-    agent_card_data = result.get("agent_card")
+    agent_card_data: dict[str, Any] = result.get("agent_card") or {}
     crewai_event_bus.emit(
         agent_branch,
         A2ADelegationCompletedEvent(
@@ -371,7 +306,7 @@ async def aexecute_a2a_delegation(
             endpoint=endpoint,
             a2a_agent_name=result.get("a2a_agent_name"),
             agent_card=agent_card_data,
-            provider=agent_card_data.get("provider") if agent_card_data else None,
+            provider=agent_card_data.get("provider"),
             metadata=metadata,
             extensions=list(extensions.keys()) if extensions else None,
             from_task=from_task,
@@ -384,7 +319,8 @@ async def aexecute_a2a_delegation(
 
 async def _aexecute_a2a_delegation_impl(
     endpoint: str,
-    auth: ClientAuthScheme | None,
+    transport_protocol: Literal["JSONRPC", "GRPC", "HTTP+JSON"],
+    auth: AuthScheme | None,
     timeout: int,
     task_description: str,
     context: str | None,
@@ -404,14 +340,8 @@ async def _aexecute_a2a_delegation_impl(
     from_task: Any | None = None,
     from_agent: Any | None = None,
     skill_id: str | None = None,
-    client_extensions: list[str] | None = None,
-    transport: ClientTransportConfig | None = None,
-    accepted_output_modes: list[str] | None = None,
-    input_files: dict[str, Any] | None = None,
 ) -> TaskStateResult:
     """Internal async implementation of A2A delegation."""
-    if transport is None:
-        transport = ClientTransportConfig()
     if auth:
         auth_data = auth.model_dump_json(
             exclude={
@@ -421,70 +351,22 @@ async def _aexecute_a2a_delegation_impl(
                 "_authorization_callback",
             }
         )
-        auth_hash = _auth_store.compute_key(type(auth).__name__, auth_data)
+        auth_hash = hash((type(auth).__name__, auth_data))
     else:
-        auth_hash = _auth_store.compute_key("none", endpoint)
-    _auth_store.set(auth_hash, auth)
+        auth_hash = 0
+    _auth_store[auth_hash] = auth
     agent_card = await _afetch_agent_card_cached(
         endpoint=endpoint, auth_hash=auth_hash, timeout=timeout
     )
 
     validate_auth_against_agent_card(agent_card, auth)
 
-    unsupported_exts = validate_required_extensions(agent_card, client_extensions)
-    if unsupported_exts:
-        ext_uris = [ext.uri for ext in unsupported_exts]
-        raise ValueError(
-            f"Agent requires extensions not supported by client: {ext_uris}"
-        )
-
-    negotiated: NegotiatedTransport | None = None
-    effective_transport: TransportType = transport.preferred or _DEFAULT_TRANSPORT
-    effective_url = endpoint
-
-    client_transports: list[str] = (
-        list(transport.supported) if transport.supported else [_DEFAULT_TRANSPORT]
-    )
-
-    try:
-        negotiated = negotiate_transport(
-            agent_card=agent_card,
-            client_supported_transports=client_transports,
-            client_preferred_transport=transport.preferred,
-            endpoint=endpoint,
-            a2a_agent_name=agent_card.name,
-        )
-        effective_transport = negotiated.transport  # type: ignore[assignment]
-        effective_url = negotiated.url
-    except TransportNegotiationError as e:
-        logger.warning(
-            "Transport negotiation failed, using fallback",
-            extra={
-                "error": str(e),
-                "fallback_transport": effective_transport,
-                "fallback_url": effective_url,
-                "endpoint": endpoint,
-                "client_transports": client_transports,
-                "server_transports": [
-                    iface.transport for iface in agent_card.additional_interfaces or []
-                ]
-                + [agent_card.preferred_transport or "JSONRPC"],
-            },
-        )
-
-    effective_output_modes = accepted_output_modes or DEFAULT_CLIENT_OUTPUT_MODES.copy()
-
-    content_negotiated = negotiate_content_types(
-        agent_card=agent_card,
-        client_output_modes=accepted_output_modes,
-        skill_name=skill_id,
-        endpoint=endpoint,
-        a2a_agent_name=agent_card.name,
-    )
-    if content_negotiated.output_modes:
-        effective_output_modes = content_negotiated.output_modes
-
-    headers, _ = await _prepare_auth_headers(auth, timeout)
+    headers: MutableMapping[str, str] = {}
+    if auth:
+        async with httpx.AsyncClient(timeout=timeout) as temp_auth_client:
+            if isinstance(auth, (HTTPDigestAuth, APIKeyAuth)):
+                configure_auth_client(auth, temp_auth_client)
+            headers = await auth.apply_auth(temp_auth_client, {})
 
     a2a_agent_name = None
     if agent_card.name:
@@ -559,13 +441,10 @@ async def _aexecute_a2a_delegation_impl(
     if skill_id:
         message_metadata["skill_id"] = skill_id
 
-    parts_list: list[Part] = [Part(root=TextPart(**parts))]
-    parts_list.extend(_create_file_parts(input_files))
-
     message = Message(
         role=Role.user,
         message_id=str(uuid.uuid4()),
-        parts=parts_list,
+        parts=[Part(root=TextPart(**parts))],
         context_id=context_id,
         task_id=task_id,
         reference_task_ids=reference_task_ids,
@@ -634,22 +513,15 @@ async def _aexecute_a2a_delegation_impl(
 
     use_streaming = not use_polling and push_config_for_client is None
 
-    client_agent_card = agent_card
-    if effective_url != agent_card.url:
-        client_agent_card = agent_card.model_copy(update={"url": effective_url})
-
     async with _create_a2a_client(
-        agent_card=client_agent_card,
-        transport_protocol=effective_transport,
+        agent_card=agent_card,
+        transport_protocol=transport_protocol,
         timeout=timeout,
         headers=headers,
         streaming=use_streaming,
         auth=auth,
         use_polling=use_polling,
         push_notification_config=push_config_for_client,
-        client_extensions=client_extensions,
-        accepted_output_modes=effective_output_modes,  # type: ignore[arg-type]
-        grpc_config=transport.grpc,
     ) as client:
         result = await handler.execute(
             client=client,
@@ -663,245 +535,6 @@ async def _aexecute_a2a_delegation_impl(
         return result
 
 
-def _normalize_grpc_metadata(
-    metadata: tuple[tuple[str, str], ...] | None,
-) -> tuple[tuple[str, str], ...] | None:
-    """Lowercase all gRPC metadata keys.
-
-    gRPC requires lowercase metadata keys, but some libraries (like the A2A SDK)
-    use mixed-case headers like 'X-A2A-Extensions'. This normalizes them.
-    """
-    if metadata is None:
-        return None
-    return tuple((key.lower(), value) for key, value in metadata)
-
-
-def _create_grpc_interceptors(
-    auth_metadata: list[tuple[str, str]] | None = None,
-) -> list[Any]:
-    """Create gRPC interceptors for metadata normalization and auth injection.
-
-    Args:
-        auth_metadata: Optional auth metadata to inject into all calls.
-            Used for insecure channels that need auth (non-localhost without TLS).
-
-    Returns a list of interceptors that lowercase metadata keys for gRPC
-    compatibility. Must be called after grpc is imported.
-    """
-    import grpc.aio  # type: ignore[import-untyped]
-
-    def _merge_metadata(
-        existing: tuple[tuple[str, str], ...] | None,
-        auth: list[tuple[str, str]] | None,
-    ) -> tuple[tuple[str, str], ...] | None:
-        """Merge existing metadata with auth metadata and normalize keys."""
-        merged: list[tuple[str, str]] = []
-        if existing:
-            merged.extend(existing)
-        if auth:
-            merged.extend(auth)
-        if not merged:
-            return None
-        return tuple((key.lower(), value) for key, value in merged)
-
-    def _inject_metadata(client_call_details: Any) -> Any:
-        """Inject merged metadata into call details."""
-        return client_call_details._replace(
-            metadata=_merge_metadata(client_call_details.metadata, auth_metadata)
-        )
-
-    class MetadataUnaryUnary(grpc.aio.UnaryUnaryClientInterceptor):  # type: ignore[misc,no-any-unimported]
-        """Interceptor for unary-unary calls that injects auth metadata."""
-
-        async def intercept_unary_unary(  # type: ignore[no-untyped-def]
-            self, continuation, client_call_details, request
-        ):
-            """Intercept unary-unary call and inject metadata."""
-            return await continuation(_inject_metadata(client_call_details), request)
-
-    class MetadataUnaryStream(grpc.aio.UnaryStreamClientInterceptor):  # type: ignore[misc,no-any-unimported]
-        """Interceptor for unary-stream calls that injects auth metadata."""
-
-        async def intercept_unary_stream(  # type: ignore[no-untyped-def]
-            self, continuation, client_call_details, request
-        ):
-            """Intercept unary-stream call and inject metadata."""
-            return await continuation(_inject_metadata(client_call_details), request)
-
-    class MetadataStreamUnary(grpc.aio.StreamUnaryClientInterceptor):  # type: ignore[misc,no-any-unimported]
-        """Interceptor for stream-unary calls that injects auth metadata."""
-
-        async def intercept_stream_unary(  # type: ignore[no-untyped-def]
-            self, continuation, client_call_details, request_iterator
-        ):
-            """Intercept stream-unary call and inject metadata."""
-            return await continuation(
-                _inject_metadata(client_call_details), request_iterator
-            )
-
-    class MetadataStreamStream(grpc.aio.StreamStreamClientInterceptor):  # type: ignore[misc,no-any-unimported]
-        """Interceptor for stream-stream calls that injects auth metadata."""
-
-        async def intercept_stream_stream(  # type: ignore[no-untyped-def]
-            self, continuation, client_call_details, request_iterator
-        ):
-            """Intercept stream-stream call and inject metadata."""
-            return await continuation(
-                _inject_metadata(client_call_details), request_iterator
-            )
-
-    return [
-        MetadataUnaryUnary(),
-        MetadataUnaryStream(),
-        MetadataStreamUnary(),
-        MetadataStreamStream(),
-    ]
-
-
-def _create_grpc_channel_factory(
-    grpc_config: GRPCClientConfig,
-    auth: ClientAuthScheme | None = None,
-) -> Callable[[str], Any]:
-    """Create a gRPC channel factory with the given configuration.
-
-    Args:
-        grpc_config: gRPC client configuration with channel options.
-        auth: Optional ClientAuthScheme for TLS and auth configuration.
-
-    Returns:
-        A callable that creates gRPC channels from URLs.
-    """
-    try:
-        import grpc
-    except ImportError as e:
-        raise ImportError(
-            "gRPC transport requires grpcio. Install with: pip install a2a-sdk[grpc]"
-        ) from e
-
-    auth_metadata: list[tuple[str, str]] = []
-
-    if auth is not None:
-        from crewai.a2a.auth.client_schemes import (
-            APIKeyAuth,
-            BearerTokenAuth,
-            HTTPBasicAuth,
-            HTTPDigestAuth,
-            OAuth2AuthorizationCode,
-            OAuth2ClientCredentials,
-        )
-
-        if isinstance(auth, HTTPDigestAuth):
-            raise ValueError(
-                "HTTPDigestAuth is not supported with gRPC transport. "
-                "Digest authentication requires HTTP challenge-response flow. "
-                "Use BearerTokenAuth, HTTPBasicAuth, APIKeyAuth (header), or OAuth2 instead."
-            )
-        if isinstance(auth, APIKeyAuth) and auth.location in ("query", "cookie"):
-            raise ValueError(
-                f"APIKeyAuth with location='{auth.location}' is not supported with gRPC transport. "
-                "gRPC only supports header-based authentication. "
-                "Use APIKeyAuth with location='header' instead."
-            )
-
-        if isinstance(auth, BearerTokenAuth):
-            auth_metadata.append(("authorization", f"Bearer {auth.token}"))
-        elif isinstance(auth, HTTPBasicAuth):
-            import base64
-
-            basic_credentials = f"{auth.username}:{auth.password}"
-            encoded = base64.b64encode(basic_credentials.encode()).decode()
-            auth_metadata.append(("authorization", f"Basic {encoded}"))
-        elif isinstance(auth, APIKeyAuth) and auth.location == "header":
-            header_name = auth.name.lower()
-            auth_metadata.append((header_name, auth.api_key))
-        elif isinstance(auth, (OAuth2ClientCredentials, OAuth2AuthorizationCode)):
-            if auth._access_token:
-                auth_metadata.append(("authorization", f"Bearer {auth._access_token}"))
-
-    def factory(url: str) -> Any:
-        """Create a gRPC channel for the given URL."""
-        target = url
-        use_tls = False
-
-        if url.startswith("grpcs://"):
-            target = url[8:]
-            use_tls = True
-        elif url.startswith("grpc://"):
-            target = url[7:]
-        elif url.startswith("https://"):
-            target = url[8:]
-            use_tls = True
-        elif url.startswith("http://"):
-            target = url[7:]
-
-        options: list[tuple[str, Any]] = []
-        if grpc_config.max_send_message_length is not None:
-            options.append(
-                ("grpc.max_send_message_length", grpc_config.max_send_message_length)
-            )
-        if grpc_config.max_receive_message_length is not None:
-            options.append(
-                (
-                    "grpc.max_receive_message_length",
-                    grpc_config.max_receive_message_length,
-                )
-            )
-        if grpc_config.keepalive_time_ms is not None:
-            options.append(("grpc.keepalive_time_ms", grpc_config.keepalive_time_ms))
-        if grpc_config.keepalive_timeout_ms is not None:
-            options.append(
-                ("grpc.keepalive_timeout_ms", grpc_config.keepalive_timeout_ms)
-            )
-
-        channel_credentials = None
-        if auth and hasattr(auth, "tls") and auth.tls:
-            channel_credentials = auth.tls.get_grpc_credentials()
-        elif use_tls:
-            channel_credentials = grpc.ssl_channel_credentials()
-
-        if channel_credentials and auth_metadata:
-
-            class AuthMetadataPlugin(grpc.AuthMetadataPlugin):  # type: ignore[misc,no-any-unimported]
-                """gRPC auth metadata plugin that adds auth headers as metadata."""
-
-                def __init__(self, metadata: list[tuple[str, str]]) -> None:
-                    self._metadata = tuple(metadata)
-
-                def __call__(  # type: ignore[no-any-unimported]
-                    self,
-                    context: grpc.AuthMetadataContext,
-                    callback: grpc.AuthMetadataPluginCallback,
-                ) -> None:
-                    callback(self._metadata, None)
-
-            call_creds = grpc.metadata_call_credentials(
-                AuthMetadataPlugin(auth_metadata)
-            )
-            credentials = grpc.composite_channel_credentials(
-                channel_credentials, call_creds
-            )
-            interceptors = _create_grpc_interceptors()
-            return grpc.aio.secure_channel(
-                target, credentials, options=options or None, interceptors=interceptors
-            )
-        if channel_credentials:
-            interceptors = _create_grpc_interceptors()
-            return grpc.aio.secure_channel(
-                target,
-                channel_credentials,
-                options=options or None,
-                interceptors=interceptors,
-            )
-        interceptors = _create_grpc_interceptors(
-            auth_metadata=auth_metadata if auth_metadata else None
-        )
-        return grpc.aio.insecure_channel(
-            target, options=options or None, interceptors=interceptors
-        )
-
-    return factory
-
-
 @asynccontextmanager
 async def _create_a2a_client(
     agent_card: AgentCard,
@@ -909,12 +542,9 @@ async def _create_a2a_client(
     timeout: int,
     headers: MutableMapping[str, str],
     streaming: bool,
-    auth: ClientAuthScheme | None = None,
+    auth: AuthScheme | None = None,
     use_polling: bool = False,
     push_notification_config: PushNotificationConfig | None = None,
-    client_extensions: list[str] | None = None,
-    accepted_output_modes: list[str] | None = None,
-    grpc_config: GRPCClientConfig | None = None,
 ) -> AsyncIterator[Client]:
     """Create and configure an A2A client.
 
@@ -924,21 +554,16 @@ async def _create_a2a_client(
         timeout: Request timeout in seconds.
         headers: HTTP headers (already with auth applied).
         streaming: Enable streaming responses.
-        auth: Optional ClientAuthScheme for client configuration.
+        auth: Optional AuthScheme for client configuration.
         use_polling: Enable polling mode.
         push_notification_config: Optional push notification config.
-        client_extensions: A2A protocol extension URIs to declare support for.
-        accepted_output_modes: MIME types the client can accept in responses.
-        grpc_config: Optional gRPC client configuration.
 
     Yields:
         Configured A2A client instance.
     """
-    verify = _get_tls_verify(auth)
     async with httpx.AsyncClient(
         timeout=timeout,
         headers=headers,
-        verify=verify,
     ) as httpx_client:
         if auth and isinstance(auth, (HTTPDigestAuth, APIKeyAuth)):
             configure_auth_client(auth, httpx_client)
@@ -954,27 +579,15 @@ async def _create_a2a_client(
                 )
             )
 
-        grpc_channel_factory = None
-        if transport_protocol == "GRPC":
-            grpc_channel_factory = _create_grpc_channel_factory(
-                grpc_config or GRPCClientConfig(),
-                auth=auth,
-            )
-
         config = ClientConfig(
             httpx_client=httpx_client,
             supported_transports=[transport_protocol],
             streaming=streaming and not use_polling,
             polling=use_polling,
-            accepted_output_modes=accepted_output_modes or DEFAULT_CLIENT_OUTPUT_MODES,  # type: ignore[arg-type]
+            accepted_output_modes=["application/json"],
             push_notification_configs=push_configs,
-            grpc_channel_factory=grpc_channel_factory,
         )
 
         factory = ClientFactory(config)
         client = factory.create(agent_card)
-
-        if client_extensions:
-            await client.add_request_middleware(ExtensionsMiddleware(client_extensions))
-
         yield client

lib/crewai/src/crewai/a2a/utils/logging.py

@@ -1,131 +0,0 @@
-"""Structured JSON logging utilities for A2A module."""
-
-from __future__ import annotations
-
-from contextvars import ContextVar
-from datetime import datetime, timezone
-import json
-import logging
-from typing import Any
-
-
-_log_context: ContextVar[dict[str, Any] | None] = ContextVar(
-    "log_context", default=None
-)
-
-
-class JSONFormatter(logging.Formatter):
-    """JSON formatter for structured logging.
-
-    Outputs logs as JSON with consistent fields for log aggregators.
-    """
-
-    def format(self, record: logging.LogRecord) -> str:
-        """Format log record as JSON string."""
-        log_data: dict[str, Any] = {
-            "timestamp": datetime.now(timezone.utc).isoformat(),
-            "level": record.levelname,
-            "logger": record.name,
-            "message": record.getMessage(),
-        }
-
-        if record.exc_info:
-            log_data["exception"] = self.formatException(record.exc_info)
-
-        context = _log_context.get()
-        if context is not None:
-            log_data.update(context)
-
-        if hasattr(record, "task_id"):
-            log_data["task_id"] = record.task_id
-        if hasattr(record, "context_id"):
-            log_data["context_id"] = record.context_id
-        if hasattr(record, "agent"):
-            log_data["agent"] = record.agent
-        if hasattr(record, "endpoint"):
-            log_data["endpoint"] = record.endpoint
-        if hasattr(record, "extension"):
-            log_data["extension"] = record.extension
-        if hasattr(record, "error"):
-            log_data["error"] = record.error
-
-        for key, value in record.__dict__.items():
-            if key.startswith("_") or key in (
-                "name",
-                "msg",
-                "args",
-                "created",
-                "filename",
-                "funcName",
-                "levelname",
-                "levelno",
-                "lineno",
-                "module",
-                "msecs",
-                "pathname",
-                "process",
-                "processName",
-                "relativeCreated",
-                "stack_info",
-                "exc_info",
-                "exc_text",
-                "thread",
-                "threadName",
-                "taskName",
-                "message",
-            ):
-                continue
-            if key not in log_data:
-                log_data[key] = value
-
-        return json.dumps(log_data, default=str)
-
-
-class LogContext:
-    """Context manager for adding fields to all logs within a scope.
-
-    Example:
-        with LogContext(task_id="abc", context_id="xyz"):
-            logger.info("Processing task")  # Includes task_id and context_id
-    """
-
-    def __init__(self, **fields: Any) -> None:
-        self._fields = fields
-        self._token: Any = None
-
-    def __enter__(self) -> LogContext:
-        current = _log_context.get() or {}
-        new_context = {**current, **self._fields}
-        self._token = _log_context.set(new_context)
-        return self
-
-    def __exit__(self, *args: Any) -> None:
-        _log_context.reset(self._token)
-
-
-def configure_json_logging(logger_name: str = "crewai.a2a") -> None:
-    """Configure JSON logging for the A2A module.
-
-    Args:
-        logger_name: Logger name to configure.
-    """
-    logger = logging.getLogger(logger_name)
-
-    for handler in logger.handlers[:]:
-        logger.removeHandler(handler)
-
-    handler = logging.StreamHandler()
-    handler.setFormatter(JSONFormatter())
-    logger.addHandler(handler)
-
-
-def get_logger(name: str) -> logging.Logger:
-    """Get a logger configured for structured JSON output.
-
-    Args:
-        name: Logger name.
-
-    Returns:
-        Configured logger instance.
-    """
-    return logging.getLogger(name)

lib/crewai/src/crewai/a2a/utils/task.py

@@ -7,40 +7,26 @@ import base64
 from collections.abc import Callable, Coroutine
 from datetime import datetime
 from functools import wraps
-import json
 import logging
 import os
-from typing import TYPE_CHECKING, Any, ParamSpec, TypeVar, TypedDict, cast
+from typing import TYPE_CHECKING, Any, ParamSpec, TypeVar, cast
 from urllib.parse import urlparse
 
 from a2a.server.agent_execution import RequestContext
 from a2a.server.events import EventQueue
 from a2a.types import (
-    Artifact,
-    FileWithBytes,
-    FileWithUri,
     InternalError,
     InvalidParamsError,
     Message,
-    Part,
     Task as A2ATask,
     TaskState,
     TaskStatus,
     TaskStatusUpdateEvent,
 )
-from a2a.utils import (
-    get_data_parts,
-    get_file_parts,
-    new_agent_text_message,
-    new_data_artifact,
-    new_text_artifact,
-)
+from a2a.utils import new_agent_text_message, new_text_artifact
 from a2a.utils.errors import ServerError
 from aiocache import SimpleMemoryCache, caches  # type: ignore[import-untyped]
-from pydantic import BaseModel
 
-from crewai.a2a.utils.agent_card import _get_server_config
-from crewai.a2a.utils.content_type import validate_message_parts
 from crewai.events.event_bus import crewai_event_bus
 from crewai.events.types.a2a_events import (
     A2AServerTaskCanceledEvent,
@@ -49,11 +35,9 @@ from crewai.events.types.a2a_events import (
     A2AServerTaskStartedEvent,
 )
 from crewai.task import Task
-from crewai.utilities.pydantic_schema_utils import create_model_from_schema
 
 
 if TYPE_CHECKING:
-    from crewai.a2a.extensions.server import ExtensionContext, ServerExtensionRegistry
     from crewai.agent import Agent
 
 
@@ -63,17 +47,7 @@ P = ParamSpec("P")
 T = TypeVar("T")
 
 
-class RedisCacheConfig(TypedDict, total=False):
-    """Configuration for aiocache Redis backend."""
-
-    cache: str
-    endpoint: str
-    port: int
-    db: int
-    password: str
-
-
-def _parse_redis_url(url: str) -> RedisCacheConfig:
+def _parse_redis_url(url: str) -> dict[str, Any]:
     """Parse a Redis URL into aiocache configuration.
 
     Args:
@@ -82,8 +56,9 @@ def _parse_redis_url(url: str) -> RedisCacheConfig:
     Returns:
         Configuration dict for aiocache.RedisCache.
     """
+
     parsed = urlparse(url)
-    config: RedisCacheConfig = {
+    config: dict[str, Any] = {
         "cache": "aiocache.RedisCache",
         "endpoint": parsed.hostname or "localhost",
         "port": parsed.port or 6379,
@@ -163,10 +138,7 @@ def cancellable(
                     if message["type"] == "message":
                         return True
             except (OSError, ConnectionError) as e:
-                logger.warning(
-                    "Cancel watcher Redis error, falling back to polling",
-                    extra={"task_id": task_id, "error": str(e)},
-                )
+                logger.warning("Cancel watcher error for task_id=%s: %s", task_id, e)
                 return await poll_for_cancel()
             return False
 
@@ -194,98 +166,7 @@ def cancellable(
     return wrapper
 
 
-def _convert_a2a_files_to_file_inputs(
-    a2a_files: list[FileWithBytes | FileWithUri],
-) -> dict[str, Any]:
-    """Convert a2a file types to crewai FileInput dict.
-
-    Args:
-        a2a_files: List of FileWithBytes or FileWithUri from a2a SDK.
-
-    Returns:
-        Dictionary mapping file names to FileInput objects.
-    """
-    try:
-        from crewai_files import File, FileBytes
-    except ImportError:
-        logger.debug("crewai_files not installed, returning empty file dict")
-        return {}
-
-    file_dict: dict[str, Any] = {}
-    for idx, a2a_file in enumerate(a2a_files):
-        if isinstance(a2a_file, FileWithBytes):
-            file_bytes = base64.b64decode(a2a_file.bytes)
-            name = a2a_file.name or f"file_{idx}"
-            file_source = FileBytes(data=file_bytes, filename=a2a_file.name)
-            file_dict[name] = File(source=file_source)
-        elif isinstance(a2a_file, FileWithUri):
-            name = a2a_file.name or f"file_{idx}"
-            file_dict[name] = File(source=a2a_file.uri)
-
-    return file_dict
-
-
-def _extract_response_schema(parts: list[Part]) -> dict[str, Any] | None:
-    """Extract response schema from message parts metadata.
-
-    The client may include a JSON schema in TextPart metadata to specify
-    the expected response format (see delegation.py line 463).
-
-    Args:
-        parts: List of message parts.
-
-    Returns:
-        JSON schema dict if found, None otherwise.
-    """
-    for part in parts:
-        if part.root.kind == "text" and part.root.metadata:
-            schema = part.root.metadata.get("schema")
-            if schema and isinstance(schema, dict):
-                return schema  # type: ignore[no-any-return]
-    return None
-
-
-def _create_result_artifact(
-    result: Any,
-    task_id: str,
-) -> Artifact:
-    """Create artifact from task result, using DataPart for structured data.
-
-    Args:
-        result: The task execution result.
-        task_id: The task ID for naming the artifact.
-
-    Returns:
-        Artifact with appropriate part type (DataPart for dict/Pydantic, TextPart for strings).
-    """
-    artifact_name = f"result_{task_id}"
-    if isinstance(result, dict):
-        return new_data_artifact(artifact_name, result)
-    if isinstance(result, BaseModel):
-        return new_data_artifact(artifact_name, result.model_dump())
-    return new_text_artifact(artifact_name, str(result))
-
-
-def _build_task_description(
-    user_message: str,
-    structured_inputs: list[dict[str, Any]],
-) -> str:
-    """Build task description including structured data if present.
-
-    Args:
-        user_message: The original user message text.
-        structured_inputs: List of structured data from DataParts.
-
-    Returns:
-        Task description with structured data appended if present.
-    """
-    if not structured_inputs:
-        return user_message
-
-    structured_json = json.dumps(structured_inputs, indent=2)
-    return f"{user_message}\n\nStructured Data:\n{structured_json}"
-
-
+@cancellable
 async def execute(
     agent: Agent,
     context: RequestContext,
@@ -297,54 +178,15 @@ async def execute(
         agent: The CrewAI agent to execute the task.
         context: The A2A request context containing the user's message.
         event_queue: The event queue for sending responses back.
+
+    TODOs:
+        * need to impl both of structured output and file inputs, depends on `file_inputs` for
+          `crewai.task.Task`, pass the below two to Task. both utils in `a2a.utils.parts`
+        * structured outputs ingestion, `structured_inputs = get_data_parts(parts=context.message.parts)`
+        * file inputs ingestion, `file_inputs = get_file_parts(parts=context.message.parts)`
     """
-    await _execute_impl(agent, context, event_queue, None, None)
-
-
-@cancellable
-async def _execute_impl(
-    agent: Agent,
-    context: RequestContext,
-    event_queue: EventQueue,
-    extension_registry: ServerExtensionRegistry | None,
-    extension_context: ExtensionContext | None,
-) -> None:
-    """Internal implementation for task execution with optional extensions."""
-    server_config = _get_server_config(agent)
-    if context.message and context.message.parts and server_config:
-        allowed_modes = server_config.default_input_modes
-        invalid_types = validate_message_parts(context.message.parts, allowed_modes)
-        if invalid_types:
-            raise ServerError(
-                InvalidParamsError(
-                    message=f"Unsupported content type(s): {', '.join(invalid_types)}. "
-                    f"Supported: {', '.join(allowed_modes)}"
-                )
-            )
-
-    if extension_registry and extension_context:
-        await extension_registry.invoke_on_request(extension_context)
 
     user_message = context.get_user_input()
-
-    response_model: type[BaseModel] | None = None
-    structured_inputs: list[dict[str, Any]] = []
-    a2a_files: list[FileWithBytes | FileWithUri] = []
-
-    if context.message and context.message.parts:
-        schema = _extract_response_schema(context.message.parts)
-        if schema:
-            try:
-                response_model = create_model_from_schema(schema)
-            except Exception as e:
-                logger.debug(
-                    "Failed to create response model from schema",
-                    extra={"error": str(e), "schema_title": schema.get("title")},
-                )
-
-        structured_inputs = get_data_parts(context.message.parts)
-        a2a_files = get_file_parts(context.message.parts)
-
     task_id = context.task_id
     context_id = context.context_id
     if task_id is None or context_id is None:
@@ -361,11 +203,9 @@ async def _execute_impl(
         raise ServerError(InvalidParamsError(message=msg)) from None
 
     task = Task(
-        description=_build_task_description(user_message, structured_inputs),
+        description=user_message,
         expected_output="Response to the user's request",
         agent=agent,
-        response_model=response_model,
-        input_files=_convert_a2a_files_to_file_inputs(a2a_files),
     )
 
     crewai_event_bus.emit(
@@ -380,10 +220,6 @@ async def _execute_impl(
 
     try:
         result = await agent.aexecute_task(task=task, tools=agent.tools)
-        if extension_registry and extension_context:
-            result = await extension_registry.invoke_on_response(
-                extension_context, result
-            )
         result_str = str(result)
         history: list[Message] = [context.message] if context.message else []
         history.append(new_agent_text_message(result_str, context_id, task_id))
@@ -391,8 +227,8 @@ async def _execute_impl(
             A2ATask(
                 id=task_id,
                 context_id=context_id,
-                status=TaskStatus(state=TaskState.completed),
-                artifacts=[_create_result_artifact(result, task_id)],
+                status=TaskStatus(state=TaskState.input_required),
+                artifacts=[new_text_artifact(result_str, f"result_{task_id}")],
                 history=history,
             )
         )
@@ -433,27 +269,6 @@ async def _execute_impl(
         ) from e
 
 
-async def execute_with_extensions(
-    agent: Agent,
-    context: RequestContext,
-    event_queue: EventQueue,
-    extension_registry: ServerExtensionRegistry,
-    extension_context: ExtensionContext,
-) -> None:
-    """Execute an A2A task with extension hooks.
-
-    Args:
-        agent: The CrewAI agent to execute the task.
-        context: The A2A request context containing the user's message.
-        event_queue: The event queue for sending responses back.
-        extension_registry: Registry of server extensions.
-        extension_context: Context for extension hooks.
-    """
-    await _execute_impl(
-        agent, context, event_queue, extension_registry, extension_context
-    )
-
-
 async def cancel(
     context: RequestContext,
     event_queue: EventQueue,

lib/crewai/src/crewai/a2a/utils/transport.py

@@ -1,215 +0,0 @@
-"""Transport negotiation utilities for A2A protocol.
-
-This module provides functionality for negotiating the transport protocol
-between an A2A client and server based on their respective capabilities
-and preferences.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Final, Literal
-
-from a2a.types import AgentCard, AgentInterface
-
-from crewai.events.event_bus import crewai_event_bus
-from crewai.events.types.a2a_events import A2ATransportNegotiatedEvent
-
-
-TransportProtocol = Literal["JSONRPC", "GRPC", "HTTP+JSON"]
-NegotiationSource = Literal["client_preferred", "server_preferred", "fallback"]
-
-JSONRPC_TRANSPORT: Literal["JSONRPC"] = "JSONRPC"
-GRPC_TRANSPORT: Literal["GRPC"] = "GRPC"
-HTTP_JSON_TRANSPORT: Literal["HTTP+JSON"] = "HTTP+JSON"
-
-DEFAULT_TRANSPORT_PREFERENCE: Final[list[TransportProtocol]] = [
-    JSONRPC_TRANSPORT,
-    GRPC_TRANSPORT,
-    HTTP_JSON_TRANSPORT,
-]
-
-
-@dataclass
-class NegotiatedTransport:
-    """Result of transport negotiation.
-
-    Attributes:
-        transport: The negotiated transport protocol.
-        url: The URL to use for this transport.
-        source: How the transport was selected ('preferred', 'additional', 'fallback').
-    """
-
-    transport: str
-    url: str
-    source: NegotiationSource
-
-
-class TransportNegotiationError(Exception):
-    """Raised when no compatible transport can be negotiated."""
-
-    def __init__(
-        self,
-        client_transports: list[str],
-        server_transports: list[str],
-        message: str | None = None,
-    ) -> None:
-        """Initialize the error with negotiation details.
-
-        Args:
-            client_transports: Transports supported by the client.
-            server_transports: Transports supported by the server.
-            message: Optional custom error message.
-        """
-        self.client_transports = client_transports
-        self.server_transports = server_transports
-        if message is None:
-            message = (
-                f"No compatible transport found. "
-                f"Client supports: {client_transports}. "
-                f"Server supports: {server_transports}."
-            )
-        super().__init__(message)
-
-
-def _get_server_interfaces(agent_card: AgentCard) -> list[AgentInterface]:
-    """Extract all available interfaces from an AgentCard.
-
-    Creates a unified list of interfaces including the primary URL and
-    any additional interfaces declared by the agent.
-
-    Args:
-        agent_card: The agent's card containing transport information.
-
-    Returns:
-        List of AgentInterface objects representing all available endpoints.
-    """
-    interfaces: list[AgentInterface] = []
-
-    primary_transport = agent_card.preferred_transport or JSONRPC_TRANSPORT
-    interfaces.append(
-        AgentInterface(
-            transport=primary_transport,
-            url=agent_card.url,
-        )
-    )
-
-    if agent_card.additional_interfaces:
-        for interface in agent_card.additional_interfaces:
-            is_duplicate = any(
-                i.url == interface.url and i.transport == interface.transport
-                for i in interfaces
-            )
-            if not is_duplicate:
-                interfaces.append(interface)
-
-    return interfaces
-
-
-def negotiate_transport(
-    agent_card: AgentCard,
-    client_supported_transports: list[str] | None = None,
-    client_preferred_transport: str | None = None,
-    emit_event: bool = True,
-    endpoint: str | None = None,
-    a2a_agent_name: str | None = None,
-) -> NegotiatedTransport:
-    """Negotiate the transport protocol between client and server.
-
-    Compares the client's supported transports with the server's available
-    interfaces to find a compatible transport and URL.
-
-    Negotiation logic:
-    1. If client_preferred_transport is set and server supports it → use it
-    2. Otherwise, if server's preferred is in client's supported → use server's
-    3. Otherwise, find first match from client's supported in server's interfaces
-
-    Args:
-        agent_card: The server's AgentCard with transport information.
-        client_supported_transports: Transports the client can use.
-            Defaults to ["JSONRPC"] if not specified.
-        client_preferred_transport: Client's preferred transport. If set and
-            server supports it, takes priority over server preference.
-        emit_event: Whether to emit a transport negotiation event.
-        endpoint: Original endpoint URL for event metadata.
-        a2a_agent_name: Agent name for event metadata.
-
-    Returns:
-        NegotiatedTransport with the selected transport, URL, and source.
-
-    Raises:
-        TransportNegotiationError: If no compatible transport is found.
-    """
-    if client_supported_transports is None:
-        client_supported_transports = [JSONRPC_TRANSPORT]
-
-    client_transports = [t.upper() for t in client_supported_transports]
-    client_preferred = (
-        client_preferred_transport.upper() if client_preferred_transport else None
-    )
-
-    server_interfaces = _get_server_interfaces(agent_card)
-    server_transports = [i.transport.upper() for i in server_interfaces]
-
-    transport_to_interface: dict[str, AgentInterface] = {}
-    for interface in server_interfaces:
-        transport_upper = interface.transport.upper()
-        if transport_upper not in transport_to_interface:
-            transport_to_interface[transport_upper] = interface
-
-    result: NegotiatedTransport | None = None
-
-    if client_preferred and client_preferred in transport_to_interface:
-        interface = transport_to_interface[client_preferred]
-        result = NegotiatedTransport(
-            transport=interface.transport,
-            url=interface.url,
-            source="client_preferred",
-        )
-    else:
-        server_preferred = (agent_card.preferred_transport or JSONRPC_TRANSPORT).upper()
-        if (
-            server_preferred in client_transports
-            and server_preferred in transport_to_interface
-        ):
-            interface = transport_to_interface[server_preferred]
-            result = NegotiatedTransport(
-                transport=interface.transport,
-                url=interface.url,
-                source="server_preferred",
-            )
-        else:
-            for transport in client_transports:
-                if transport in transport_to_interface:
-                    interface = transport_to_interface[transport]
-                    result = NegotiatedTransport(
-                        transport=interface.transport,
-                        url=interface.url,
-                        source="fallback",
-                    )
-                    break
-
-    if result is None:
-        raise TransportNegotiationError(
-            client_transports=client_transports,
-            server_transports=server_transports,
-        )
-
-    if emit_event:
-        crewai_event_bus.emit(
-            None,
-            A2ATransportNegotiatedEvent(
-                endpoint=endpoint or agent_card.url,
-                a2a_agent_name=a2a_agent_name or agent_card.name,
-                negotiated_transport=result.transport,
-                negotiated_url=result.url,
-                source=result.source,
-                client_supported_transports=client_transports,
-                server_supported_transports=server_transports,
-                server_preferred_transport=agent_card.preferred_transport
-                or JSONRPC_TRANSPORT,
-                client_preferred_transport=client_preferred,
-            ),
-        )
-
-    return result

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

@@ -94,12 +94,6 @@ from crewai.utilities.token_counter_callback import TokenCalcHandler
 from crewai.utilities.training_handler import CrewTrainingHandler
 
 
-try:
-    from crewai.a2a.types import AgentResponseProtocol
-except ImportError:
-    AgentResponseProtocol = None  # type: ignore[assignment, misc]
-
-
 if TYPE_CHECKING:
     from crewai_files import FileInput
     from crewai_tools import CodeInterpreterTool
@@ -496,22 +490,9 @@ class Agent(BaseAgent):
             self._rpm_controller.stop_rpm_counter()
 
         result = process_tool_results(self, result)
-
-        output_for_event = result
-        if (
-            AgentResponseProtocol is not None
-            and isinstance(result, BaseModel)
-            and isinstance(result, AgentResponseProtocol)
-        ):
-            output_for_event = str(result.message)
-        elif not isinstance(result, str):
-            output_for_event = str(result)
-
         crewai_event_bus.emit(
             self,
-            event=AgentExecutionCompletedEvent(
-                agent=self, task=task, output=output_for_event
-            ),
+            event=AgentExecutionCompletedEvent(agent=self, task=task, output=result),
         )
 
         save_last_messages(self)
@@ -728,22 +709,9 @@ class Agent(BaseAgent):
             self._rpm_controller.stop_rpm_counter()
 
         result = process_tool_results(self, result)
-
-        output_for_event = result
-        if (
-            AgentResponseProtocol is not None
-            and isinstance(result, BaseModel)
-            and isinstance(result, AgentResponseProtocol)
-        ):
-            output_for_event = str(result.message)
-        elif not isinstance(result, str):
-            output_for_event = str(result)
-
         crewai_event_bus.emit(
             self,
-            event=AgentExecutionCompletedEvent(
-                agent=self, task=task, output=output_for_event
-            ),
+            event=AgentExecutionCompletedEvent(agent=self, task=task, output=result),
         )
 
         save_last_messages(self)
@@ -1890,17 +1858,11 @@ class Agent(BaseAgent):
 
         # Execute the agent (this is called from sync path, so invoke returns dict)
         result = cast(dict[str, Any], executor.invoke(inputs))
-        output = result.get("output", "")
+        raw_output = result.get("output", "")
 
         # Handle response format conversion
         formatted_result: BaseModel | None = None
-        raw_output: str
-
-        if isinstance(output, BaseModel):
-            formatted_result = output
-            raw_output = output.model_dump_json()
-        elif response_format:
-            raw_output = str(output) if not isinstance(output, str) else output
+        if response_format:
             try:
                 model_schema = generate_model_description(response_format)
                 schema = json.dumps(model_schema, indent=2)
@@ -1920,8 +1882,6 @@ class Agent(BaseAgent):
                     formatted_result = conversion_result
             except ConverterError:
                 pass  # Keep raw output if conversion fails
-        else:
-            raw_output = str(output) if not isinstance(output, str) else output
 
         # Get token usage metrics
         if isinstance(self.llm, BaseLLM):
@@ -1929,16 +1889,8 @@ class Agent(BaseAgent):
         else:
             usage_metrics = self._token_process.get_summary()
 
-        raw_str = (
-            raw_output
-            if isinstance(raw_output, str)
-            else raw_output.model_dump_json()
-            if isinstance(raw_output, BaseModel)
-            else str(raw_output)
-        )
-
         return LiteAgentOutput(
-            raw=raw_str,
+            raw=raw_output,
             pydantic=formatted_result,
             agent_role=self.role,
             usage_metrics=usage_metrics.model_dump() if usage_metrics else None,
@@ -1968,17 +1920,11 @@ class Agent(BaseAgent):
 
         # Execute the agent asynchronously
         result = await executor.invoke_async(inputs)
-        output = result.get("output", "")
+        raw_output = result.get("output", "")
 
         # Handle response format conversion
         formatted_result: BaseModel | None = None
-        raw_output: str
-
-        if isinstance(output, BaseModel):
-            formatted_result = output
-            raw_output = output.model_dump_json()
-        elif response_format:
-            raw_output = str(output) if not isinstance(output, str) else output
+        if response_format:
             try:
                 model_schema = generate_model_description(response_format)
                 schema = json.dumps(model_schema, indent=2)
@@ -1998,8 +1944,6 @@ class Agent(BaseAgent):
                     formatted_result = conversion_result
             except ConverterError:
                 pass  # Keep raw output if conversion fails
-        else:
-            raw_output = str(output) if not isinstance(output, str) else output
 
         # Get token usage metrics
         if isinstance(self.llm, BaseLLM):
@@ -2007,16 +1951,8 @@ class Agent(BaseAgent):
         else:
             usage_metrics = self._token_process.get_summary()
 
-        raw_str = (
-            raw_output
-            if isinstance(raw_output, str)
-            else raw_output.model_dump_json()
-            if isinstance(raw_output, BaseModel)
-            else str(raw_output)
-        )
-
         return LiteAgentOutput(
-            raw=raw_str,
+            raw=raw_output,
             pydantic=formatted_result,
             agent_role=self.role,
             usage_metrics=usage_metrics.model_dump() if usage_metrics else None,

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

@@ -37,8 +37,7 @@ class CrewAgentExecutorMixin:
             self.crew
             and self.agent
             and self.task
-            and f"Action: {sanitize_tool_name('Delegate work to coworker')}"
-            not in output.text
+            and f"Action: {sanitize_tool_name('Delegate work to coworker')}" not in output.text
         ):
             try:
                 if (
@@ -133,11 +132,10 @@ class CrewAgentExecutorMixin:
             and self.crew._long_term_memory
             and self.crew._entity_memory is None
         ):
-            if self.agent and self.agent.verbose:
-                self._printer.print(
-                    content="Long term memory is enabled, but entity memory is not enabled. Please configure entity memory or set memory=True to automatically enable it.",
-                    color="bold_yellow",
-                )
+            self._printer.print(
+                content="Long term memory is enabled, but entity memory is not enabled. Please configure entity memory or set memory=True to automatically enable it.",
+                color="bold_yellow",
+            )
 
     def _ask_human_input(self, final_answer: str) -> str:
         """Prompt human input with mode-appropriate messaging.

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

@@ -28,11 +28,6 @@ from crewai.hooks.llm_hooks import (
     get_after_llm_call_hooks,
     get_before_llm_call_hooks,
 )
-from crewai.hooks.tool_hooks import (
-    ToolCallHookContext,
-    get_after_tool_call_hooks,
-    get_before_tool_call_hooks,
-)
 from crewai.utilities.agent_utils import (
     aget_llm_response,
     convert_tools_to_openai_schema,
@@ -206,14 +201,13 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
         try:
             formatted_answer = self._invoke_loop()
         except AssertionError:
-            if self.agent.verbose:
-                self._printer.print(
-                    content="Agent failed to reach a final answer. This is likely a bug - please report it.",
-                    color="red",
-                )
+            self._printer.print(
+                content="Agent failed to reach a final answer. This is likely a bug - please report it.",
+                color="red",
+            )
             raise
         except Exception as e:
-            handle_unknown_error(self._printer, e, verbose=self.agent.verbose)
+            handle_unknown_error(self._printer, e)
             raise
 
         if self.ask_for_human_input:
@@ -328,7 +322,6 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                         messages=self.messages,
                         llm=self.llm,
                         callbacks=self.callbacks,
-                        verbose=self.agent.verbose,
                     )
                     break
 
@@ -343,41 +336,22 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                     from_agent=self.agent,
                     response_model=self.response_model,
                     executor_context=self,
-                    verbose=self.agent.verbose,
                 )
                 # breakpoint()
                 if self.response_model is not None:
                     try:
-                        if isinstance(answer, BaseModel):
-                            output_json = answer.model_dump_json()
-                            formatted_answer = AgentFinish(
-                                thought="",
-                                output=answer,
-                                text=output_json,
-                            )
-                        else:
-                            self.response_model.model_validate_json(answer)
-                            formatted_answer = AgentFinish(
-                                thought="",
-                                output=answer,
-                                text=answer,
-                            )
-                    except ValidationError:
-                        # If validation fails, convert BaseModel to JSON string for parsing
-                        answer_str = (
-                            answer.model_dump_json()
-                            if isinstance(answer, BaseModel)
-                            else str(answer)
+                        self.response_model.model_validate_json(answer)
+                        formatted_answer = AgentFinish(
+                            thought="",
+                            output=answer,
+                            text=answer,
                         )
+                    except ValidationError:
                         formatted_answer = process_llm_response(
-                            answer_str, self.use_stop_words
+                            answer, self.use_stop_words
                         )  # type: ignore[assignment]
                 else:
-                    # When no response_model, answer should be a string
-                    answer_str = str(answer) if not isinstance(answer, str) else answer
-                    formatted_answer = process_llm_response(
-                        answer_str, self.use_stop_words
-                    )  # type: ignore[assignment]
+                    formatted_answer = process_llm_response(answer, self.use_stop_words)  # type: ignore[assignment]
 
                 if isinstance(formatted_answer, AgentAction):
                     # Extract agent fingerprint if available
@@ -420,7 +394,6 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                     iterations=self.iterations,
                     log_error_after=self.log_error_after,
                     printer=self._printer,
-                    verbose=self.agent.verbose,
                 )
 
             except Exception as e:
@@ -435,10 +408,9 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                         llm=self.llm,
                         callbacks=self.callbacks,
                         i18n=self._i18n,
-                        verbose=self.agent.verbose,
                     )
                     continue
-                handle_unknown_error(self._printer, e, verbose=self.agent.verbose)
+                handle_unknown_error(self._printer, e)
                 raise e
             finally:
                 self.iterations += 1
@@ -484,7 +456,6 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                         messages=self.messages,
                         llm=self.llm,
                         callbacks=self.callbacks,
-                        verbose=self.agent.verbose,
                     )
                     self._show_logs(formatted_answer)
                     return formatted_answer
@@ -506,7 +477,6 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                     from_agent=self.agent,
                     response_model=self.response_model,
                     executor_context=self,
-                    verbose=self.agent.verbose,
                 )
 
                 # Check if the response is a list of tool calls
@@ -538,18 +508,6 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                     self._show_logs(formatted_answer)
                     return formatted_answer
 
-                if isinstance(answer, BaseModel):
-                    output_json = answer.model_dump_json()
-                    formatted_answer = AgentFinish(
-                        thought="",
-                        output=answer,
-                        text=output_json,
-                    )
-                    self._invoke_step_callback(formatted_answer)
-                    self._append_message(output_json)
-                    self._show_logs(formatted_answer)
-                    return formatted_answer
-
                 # Unexpected response type, treat as final answer
                 formatted_answer = AgentFinish(
                     thought="",
@@ -572,10 +530,9 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                         llm=self.llm,
                         callbacks=self.callbacks,
                         i18n=self._i18n,
-                        verbose=self.agent.verbose,
                     )
                     continue
-                handle_unknown_error(self._printer, e, verbose=self.agent.verbose)
+                handle_unknown_error(self._printer, e)
                 raise e
             finally:
                 self.iterations += 1
@@ -597,23 +554,13 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
             from_agent=self.agent,
             response_model=self.response_model,
             executor_context=self,
-            verbose=self.agent.verbose,
         )
 
-        if isinstance(answer, BaseModel):
-            output_json = answer.model_dump_json()
-            formatted_answer = AgentFinish(
-                thought="",
-                output=answer,
-                text=output_json,
-            )
-        else:
-            answer_str = answer if isinstance(answer, str) else str(answer)
-            formatted_answer = AgentFinish(
-                thought="",
-                output=answer_str,
-                text=answer_str,
-            )
+        formatted_answer = AgentFinish(
+            thought="",
+            output=str(answer),
+            text=str(answer),
+        )
         self._show_logs(formatted_answer)
         return formatted_answer
 
@@ -802,42 +749,8 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
 
         track_delegation_if_needed(func_name, args_dict, self.task)
 
-        # Find the structured tool for hook context
-        structured_tool: CrewStructuredTool | None = None
-        for structured in self.tools or []:
-            if sanitize_tool_name(structured.name) == func_name:
-                structured_tool = structured
-                break
-
-        # Execute before_tool_call hooks
-        hook_blocked = False
-        before_hook_context = ToolCallHookContext(
-            tool_name=func_name,
-            tool_input=args_dict,
-            tool=structured_tool,  # type: ignore[arg-type]
-            agent=self.agent,
-            task=self.task,
-            crew=self.crew,
-        )
-        before_hooks = get_before_tool_call_hooks()
-        try:
-            for hook in before_hooks:
-                hook_result = hook(before_hook_context)
-                if hook_result is False:
-                    hook_blocked = True
-                    break
-        except Exception as hook_error:
-            if self.agent.verbose:
-                self._printer.print(
-                    content=f"Error in before_tool_call hook: {hook_error}",
-                    color="red",
-                )
-
-        # If hook blocked execution, set result and skip tool execution
-        if hook_blocked:
-            result = f"Tool execution blocked by hook. Tool: {func_name}"
-        # Execute the tool (only if not cached, not at max usage, and not blocked by hook)
-        elif not from_cache and not max_usage_reached:
+        # Execute the tool (only if not cached and not at max usage)
+        if not from_cache and not max_usage_reached:
             result = "Tool not found"
             if func_name in available_functions:
                 try:
@@ -885,29 +798,6 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
             # Return error message when max usage limit is reached
             result = f"Tool '{func_name}' has reached its usage limit of {original_tool.max_usage_count} times and cannot be used anymore."
 
-        after_hook_context = ToolCallHookContext(
-            tool_name=func_name,
-            tool_input=args_dict,
-            tool=structured_tool,  # type: ignore[arg-type]
-            agent=self.agent,
-            task=self.task,
-            crew=self.crew,
-            tool_result=result,
-        )
-        after_hooks = get_after_tool_call_hooks()
-        try:
-            for after_hook in after_hooks:
-                after_hook_result = after_hook(after_hook_context)
-                if after_hook_result is not None:
-                    result = after_hook_result
-                    after_hook_context.tool_result = result
-        except Exception as hook_error:
-            if self.agent.verbose:
-                self._printer.print(
-                    content=f"Error in after_tool_call hook: {hook_error}",
-                    color="red",
-                )
-
         # Emit tool usage finished event
         crewai_event_bus.emit(
             self,
@@ -992,14 +882,13 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
         try:
             formatted_answer = await self._ainvoke_loop()
         except AssertionError:
-            if self.agent.verbose:
-                self._printer.print(
-                    content="Agent failed to reach a final answer. This is likely a bug - please report it.",
-                    color="red",
-                )
+            self._printer.print(
+                content="Agent failed to reach a final answer. This is likely a bug - please report it.",
+                color="red",
+            )
             raise
         except Exception as e:
-            handle_unknown_error(self._printer, e, verbose=self.agent.verbose)
+            handle_unknown_error(self._printer, e)
             raise
 
         if self.ask_for_human_input:
@@ -1050,7 +939,6 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                         messages=self.messages,
                         llm=self.llm,
                         callbacks=self.callbacks,
-                        verbose=self.agent.verbose,
                     )
                     break
 
@@ -1065,41 +953,22 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                     from_agent=self.agent,
                     response_model=self.response_model,
                     executor_context=self,
-                    verbose=self.agent.verbose,
                 )
 
                 if self.response_model is not None:
                     try:
-                        if isinstance(answer, BaseModel):
-                            output_json = answer.model_dump_json()
-                            formatted_answer = AgentFinish(
-                                thought="",
-                                output=answer,
-                                text=output_json,
-                            )
-                        else:
-                            self.response_model.model_validate_json(answer)
-                            formatted_answer = AgentFinish(
-                                thought="",
-                                output=answer,
-                                text=answer,
-                            )
-                    except ValidationError:
-                        # If validation fails, convert BaseModel to JSON string for parsing
-                        answer_str = (
-                            answer.model_dump_json()
-                            if isinstance(answer, BaseModel)
-                            else str(answer)
+                        self.response_model.model_validate_json(answer)
+                        formatted_answer = AgentFinish(
+                            thought="",
+                            output=answer,
+                            text=answer,
                         )
+                    except ValidationError:
                         formatted_answer = process_llm_response(
-                            answer_str, self.use_stop_words
+                            answer, self.use_stop_words
                         )  # type: ignore[assignment]
                 else:
-                    # When no response_model, answer should be a string
-                    answer_str = str(answer) if not isinstance(answer, str) else answer
-                    formatted_answer = process_llm_response(
-                        answer_str, self.use_stop_words
-                    )  # type: ignore[assignment]
+                    formatted_answer = process_llm_response(answer, self.use_stop_words)  # type: ignore[assignment]
 
                 if isinstance(formatted_answer, AgentAction):
                     fingerprint_context = {}
@@ -1141,7 +1010,6 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                     iterations=self.iterations,
                     log_error_after=self.log_error_after,
                     printer=self._printer,
-                    verbose=self.agent.verbose,
                 )
 
             except Exception as e:
@@ -1155,10 +1023,9 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                         llm=self.llm,
                         callbacks=self.callbacks,
                         i18n=self._i18n,
-                        verbose=self.agent.verbose,
                     )
                     continue
-                handle_unknown_error(self._printer, e, verbose=self.agent.verbose)
+                handle_unknown_error(self._printer, e)
                 raise e
             finally:
                 self.iterations += 1
@@ -1198,7 +1065,6 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                         messages=self.messages,
                         llm=self.llm,
                         callbacks=self.callbacks,
-                        verbose=self.agent.verbose,
                     )
                     self._show_logs(formatted_answer)
                     return formatted_answer
@@ -1220,7 +1086,6 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                     from_agent=self.agent,
                     response_model=self.response_model,
                     executor_context=self,
-                    verbose=self.agent.verbose,
                 )
                 # Check if the response is a list of tool calls
                 if (
@@ -1251,18 +1116,6 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                     self._show_logs(formatted_answer)
                     return formatted_answer
 
-                if isinstance(answer, BaseModel):
-                    output_json = answer.model_dump_json()
-                    formatted_answer = AgentFinish(
-                        thought="",
-                        output=answer,
-                        text=output_json,
-                    )
-                    self._invoke_step_callback(formatted_answer)
-                    self._append_message(output_json)
-                    self._show_logs(formatted_answer)
-                    return formatted_answer
-
                 # Unexpected response type, treat as final answer
                 formatted_answer = AgentFinish(
                     thought="",
@@ -1285,10 +1138,9 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                         llm=self.llm,
                         callbacks=self.callbacks,
                         i18n=self._i18n,
-                        verbose=self.agent.verbose,
                     )
                     continue
-                handle_unknown_error(self._printer, e, verbose=self.agent.verbose)
+                handle_unknown_error(self._printer, e)
                 raise e
             finally:
                 self.iterations += 1
@@ -1310,23 +1162,13 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
             from_agent=self.agent,
             response_model=self.response_model,
             executor_context=self,
-            verbose=self.agent.verbose,
         )
 
-        if isinstance(answer, BaseModel):
-            output_json = answer.model_dump_json()
-            formatted_answer = AgentFinish(
-                thought="",
-                output=answer,
-                text=output_json,
-            )
-        else:
-            answer_str = answer if isinstance(answer, str) else str(answer)
-            formatted_answer = AgentFinish(
-                thought="",
-                output=answer_str,
-                text=answer_str,
-            )
+        formatted_answer = AgentFinish(
+            thought="",
+            output=str(answer),
+            text=str(answer),
+        )
         self._show_logs(formatted_answer)
         return formatted_answer
 
@@ -1437,11 +1279,10 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
         )
 
         if train_iteration is None or not isinstance(train_iteration, int):
-            if self.agent.verbose:
-                self._printer.print(
-                    content="Invalid or missing train iteration. Cannot save training data.",
-                    color="red",
-                )
+            self._printer.print(
+                content="Invalid or missing train iteration. Cannot save training data.",
+                color="red",
+            )
             return
 
         training_handler = CrewTrainingHandler(TRAINING_DATA_FILE)
@@ -1461,14 +1302,13 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
             if train_iteration in agent_training_data:
                 agent_training_data[train_iteration]["improved_output"] = result.output
             else:
-                if self.agent.verbose:
-                    self._printer.print(
-                        content=(
-                            f"No existing training data for agent {agent_id} and iteration "
-                            f"{train_iteration}. Cannot save improved output."
-                        ),
-                        color="red",
-                    )
+                self._printer.print(
+                    content=(
+                        f"No existing training data for agent {agent_id} and iteration "
+                        f"{train_iteration}. Cannot save improved output."
+                    ),
+                    color="red",
+                )
                 return
 
         # Update the training data and save
@@ -1499,12 +1339,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
         Returns:
             Final answer after feedback.
         """
-        output_str = (
-            formatted_answer.output
-            if isinstance(formatted_answer.output, str)
-            else formatted_answer.output.model_dump_json()
-        )
-        human_feedback = self._ask_human_input(output_str)
+        human_feedback = self._ask_human_input(formatted_answer.output)
 
         if self._is_training_mode():
             return self._handle_training_feedback(formatted_answer, human_feedback)
@@ -1563,12 +1398,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                 self.ask_for_human_input = False
             else:
                 answer = self._process_feedback_iteration(feedback)
-                output_str = (
-                    answer.output
-                    if isinstance(answer.output, str)
-                    else answer.output.model_dump_json()
-                )
-                feedback = self._ask_human_input(output_str)
+                feedback = self._ask_human_input(answer.output)
 
         return answer
 

lib/crewai/src/crewai/agents/parser.py

@@ -8,7 +8,6 @@ AgentAction or AgentFinish objects.
 from dataclasses import dataclass
 
 from json_repair import repair_json  # type: ignore[import-untyped]
-from pydantic import BaseModel
 
 from crewai.agents.constants import (
     ACTION_INPUT_ONLY_REGEX,
@@ -41,7 +40,7 @@ class AgentFinish:
     """Represents the final answer from an agent."""
 
     thought: str
-    output: str | BaseModel
+    output: str
     text: str
 
 

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

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

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

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

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

@@ -654,165 +654,3 @@ class A2AParallelDelegationCompletedEvent(A2AEventBase):
     success_count: int
     failure_count: int
     results: dict[str, str] | None = None
-
-
-class A2ATransportNegotiatedEvent(A2AEventBase):
-    """Event emitted when transport protocol is negotiated with an A2A agent.
-
-    This event is emitted after comparing client and server transport capabilities
-    to select the optimal transport protocol and endpoint URL.
-
-    Attributes:
-        endpoint: Original A2A agent endpoint URL.
-        a2a_agent_name: Name of the A2A agent from agent card.
-        negotiated_transport: The transport protocol selected (JSONRPC, GRPC, HTTP+JSON).
-        negotiated_url: The URL to use for the selected transport.
-        source: How the transport was selected ('client_preferred', 'server_preferred', 'fallback').
-        client_supported_transports: Transports the client can use.
-        server_supported_transports: Transports the server supports.
-        server_preferred_transport: The server's preferred transport from AgentCard.
-        client_preferred_transport: The client's preferred transport if set.
-        metadata: Custom A2A metadata key-value pairs.
-    """
-
-    type: str = "a2a_transport_negotiated"
-    endpoint: str
-    a2a_agent_name: str | None = None
-    negotiated_transport: str
-    negotiated_url: str
-    source: str
-    client_supported_transports: list[str]
-    server_supported_transports: list[str]
-    server_preferred_transport: str
-    client_preferred_transport: str | None = None
-    metadata: dict[str, Any] | None = None
-
-
-class A2AContentTypeNegotiatedEvent(A2AEventBase):
-    """Event emitted when content types are negotiated with an A2A agent.
-
-    This event is emitted after comparing client and server input/output mode
-    capabilities to determine compatible MIME types for communication.
-
-    Attributes:
-        endpoint: A2A agent endpoint URL.
-        a2a_agent_name: Name of the A2A agent from agent card.
-        skill_name: Skill name if negotiation was skill-specific.
-        client_input_modes: MIME types the client can send.
-        client_output_modes: MIME types the client can accept.
-        server_input_modes: MIME types the server accepts.
-        server_output_modes: MIME types the server produces.
-        negotiated_input_modes: Compatible input MIME types selected.
-        negotiated_output_modes: Compatible output MIME types selected.
-        negotiation_success: Whether compatible types were found for both directions.
-        metadata: Custom A2A metadata key-value pairs.
-    """
-
-    type: str = "a2a_content_type_negotiated"
-    endpoint: str
-    a2a_agent_name: str | None = None
-    skill_name: str | None = None
-    client_input_modes: list[str]
-    client_output_modes: list[str]
-    server_input_modes: list[str]
-    server_output_modes: list[str]
-    negotiated_input_modes: list[str]
-    negotiated_output_modes: list[str]
-    negotiation_success: bool = True
-    metadata: dict[str, Any] | None = None
-
-
-# -----------------------------------------------------------------------------
-# Context Lifecycle Events
-# -----------------------------------------------------------------------------
-
-
-class A2AContextCreatedEvent(A2AEventBase):
-    """Event emitted when an A2A context is created.
-
-    Contexts group related tasks in a conversation or workflow.
-
-    Attributes:
-        context_id: Unique identifier for the context.
-        created_at: Unix timestamp when context was created.
-        metadata: Custom A2A metadata key-value pairs.
-    """
-
-    type: str = "a2a_context_created"
-    context_id: str
-    created_at: float
-    metadata: dict[str, Any] | None = None
-
-
-class A2AContextExpiredEvent(A2AEventBase):
-    """Event emitted when an A2A context expires due to TTL.
-
-    Attributes:
-        context_id: The expired context identifier.
-        created_at: Unix timestamp when context was created.
-        age_seconds: How long the context existed before expiring.
-        task_count: Number of tasks in the context when expired.
-        metadata: Custom A2A metadata key-value pairs.
-    """
-
-    type: str = "a2a_context_expired"
-    context_id: str
-    created_at: float
-    age_seconds: float
-    task_count: int
-    metadata: dict[str, Any] | None = None
-
-
-class A2AContextIdleEvent(A2AEventBase):
-    """Event emitted when an A2A context becomes idle.
-
-    Idle contexts have had no activity for the configured threshold.
-
-    Attributes:
-        context_id: The idle context identifier.
-        idle_seconds: Seconds since last activity.
-        task_count: Number of tasks in the context.
-        metadata: Custom A2A metadata key-value pairs.
-    """
-
-    type: str = "a2a_context_idle"
-    context_id: str
-    idle_seconds: float
-    task_count: int
-    metadata: dict[str, Any] | None = None
-
-
-class A2AContextCompletedEvent(A2AEventBase):
-    """Event emitted when all tasks in an A2A context complete.
-
-    Attributes:
-        context_id: The completed context identifier.
-        total_tasks: Total number of tasks that were in the context.
-        duration_seconds: Total context lifetime in seconds.
-        metadata: Custom A2A metadata key-value pairs.
-    """
-
-    type: str = "a2a_context_completed"
-    context_id: str
-    total_tasks: int
-    duration_seconds: float
-    metadata: dict[str, Any] | None = None
-
-
-class A2AContextPrunedEvent(A2AEventBase):
-    """Event emitted when an A2A context is pruned (deleted).
-
-    Pruning removes the context metadata and optionally associated tasks.
-
-    Attributes:
-        context_id: The pruned context identifier.
-        task_count: Number of tasks that were in the context.
-        age_seconds: How long the context existed before pruning.
-        metadata: Custom A2A metadata key-value pairs.
-    """
-
-    type: str = "a2a_context_pruned"
-    context_id: str
-    task_count: int
-    age_seconds: float
-    metadata: dict[str, Any] | None = None

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

@@ -84,4 +84,3 @@ class LLMStreamChunkEvent(LLMEventBase):
     chunk: str
     tool_call: ToolCall | None = None
     call_type: LLMCallType | None = None
-    response_id: str | None = None

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

@@ -36,12 +36,6 @@ from crewai.hooks.llm_hooks import (
     get_after_llm_call_hooks,
     get_before_llm_call_hooks,
 )
-from crewai.hooks.tool_hooks import (
-    ToolCallHookContext,
-    get_after_tool_call_hooks,
-    get_before_tool_call_hooks,
-)
-from crewai.hooks.types import AfterLLMCallHookType, BeforeLLMCallHookType
 from crewai.utilities.agent_utils import (
     convert_tools_to_openai_schema,
     enforce_rpm_limit,
@@ -191,8 +185,8 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
 
         self._instance_id = str(uuid4())[:8]
 
-        self.before_llm_call_hooks: list[BeforeLLMCallHookType] = []
-        self.after_llm_call_hooks: list[AfterLLMCallHookType] = []
+        self.before_llm_call_hooks: list[Callable] = []
+        self.after_llm_call_hooks: list[Callable] = []
         self.before_llm_call_hooks.extend(get_before_llm_call_hooks())
         self.after_llm_call_hooks.extend(get_after_llm_call_hooks())
 
@@ -305,21 +299,11 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
         """Compatibility property for mixin - returns state messages."""
         return self._state.messages
 
-    @messages.setter
-    def messages(self, value: list[LLMMessage]) -> None:
-        """Set state messages."""
-        self._state.messages = value
-
     @property
     def iterations(self) -> int:
         """Compatibility property for mixin - returns state iterations."""
         return self._state.iterations
 
-    @iterations.setter
-    def iterations(self, value: int) -> None:
-        """Set state iterations."""
-        self._state.iterations = value
-
     @start()
     def initialize_reasoning(self) -> Literal["initialized"]:
         """Initialize the reasoning flow and emit agent start logs."""
@@ -341,7 +325,6 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
             messages=list(self.state.messages),
             llm=self.llm,
             callbacks=self.callbacks,
-            verbose=self.agent.verbose,
         )
 
         self.state.current_answer = formatted_answer
@@ -365,20 +348,10 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
                 printer=self._printer,
                 from_task=self.task,
                 from_agent=self.agent,
-                response_model=self.response_model,
+                response_model=None,
                 executor_context=self,
-                verbose=self.agent.verbose,
             )
 
-            # If response is structured output (BaseModel), store it directly
-            if isinstance(answer, BaseModel):
-                self.state.current_answer = AgentFinish(
-                    thought="",
-                    output=answer,
-                    text=str(answer),
-                )
-                return "parsed"
-
             # Parse the LLM response
             formatted_answer = process_llm_response(answer, self.use_stop_words)
 
@@ -412,7 +385,7 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
                 return "context_error"
             if e.__class__.__module__.startswith("litellm"):
                 raise e
-            handle_unknown_error(self._printer, e, verbose=self.agent.verbose)
+            handle_unknown_error(self._printer, e)
             raise
 
     @listen("continue_reasoning_native")
@@ -445,9 +418,8 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
                 available_functions=None,
                 from_task=self.task,
                 from_agent=self.agent,
-                response_model=self.response_model,
+                response_model=None,
                 executor_context=self,
-                verbose=self.agent.verbose,
             )
 
             # Check if the response is a list of tool calls
@@ -457,16 +429,6 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
 
                 return "native_tool_calls"
 
-            if isinstance(answer, BaseModel):
-                self.state.current_answer = AgentFinish(
-                    thought="",
-                    output=answer,
-                    text=answer.model_dump_json(),
-                )
-                self._invoke_step_callback(self.state.current_answer)
-                self._append_message_to_state(answer.model_dump_json())
-                return "native_finished"
-
             # Text response - this is the final answer
             if isinstance(answer, str):
                 self.state.current_answer = AgentFinish(
@@ -496,7 +458,7 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
                 return "context_error"
             if e.__class__.__module__.startswith("litellm"):
                 raise e
-            handle_unknown_error(self._printer, e, verbose=self.agent.verbose)
+            handle_unknown_error(self._printer, e)
             raise
 
     @router(call_llm_and_parse)
@@ -615,12 +577,6 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
                 "content": None,
                 "tool_calls": tool_calls_to_report,
             }
-            if all(
-                type(tc).__qualname__ == "Part" for tc in self.state.pending_tool_calls
-            ):
-                assistant_message["raw_tool_call_parts"] = list(
-                    self.state.pending_tool_calls
-                )
             self.state.messages.append(assistant_message)
 
         # Now execute each tool
@@ -655,12 +611,14 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
 
             # Check if tool has reached max usage count
             max_usage_reached = False
-            if (
-                original_tool
-                and original_tool.max_usage_count is not None
-                and original_tool.current_usage_count >= original_tool.max_usage_count
-            ):
-                max_usage_reached = True
+            if original_tool:
+                if (
+                    hasattr(original_tool, "max_usage_count")
+                    and original_tool.max_usage_count is not None
+                    and original_tool.current_usage_count
+                    >= original_tool.max_usage_count
+                ):
+                    max_usage_reached = True
 
             # Check cache before executing
             from_cache = False
@@ -692,38 +650,8 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
 
             track_delegation_if_needed(func_name, args_dict, self.task)
 
-            structured_tool: CrewStructuredTool | None = None
-            for structured in self.tools or []:
-                if sanitize_tool_name(structured.name) == func_name:
-                    structured_tool = structured
-                    break
-
-            hook_blocked = False
-            before_hook_context = ToolCallHookContext(
-                tool_name=func_name,
-                tool_input=args_dict,
-                tool=structured_tool,  # type: ignore[arg-type]
-                agent=self.agent,
-                task=self.task,
-                crew=self.crew,
-            )
-            before_hooks = get_before_tool_call_hooks()
-            try:
-                for hook in before_hooks:
-                    hook_result = hook(before_hook_context)
-                    if hook_result is False:
-                        hook_blocked = True
-                        break
-            except Exception as hook_error:
-                if self.agent.verbose:
-                    self._printer.print(
-                        content=f"Error in before_tool_call hook: {hook_error}",
-                        color="red",
-                    )
-
-            if hook_blocked:
-                result = f"Tool execution blocked by hook. Tool: {func_name}"
-            elif not from_cache and not max_usage_reached:
+            # Execute the tool (only if not cached and not at max usage)
+            if not from_cache and not max_usage_reached:
                 result = "Tool not found"
                 if func_name in self._available_functions:
                     try:
@@ -733,7 +661,11 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
                         # Add to cache after successful execution (before string conversion)
                         if self.tools_handler and self.tools_handler.cache:
                             should_cache = True
-                            if original_tool:
+                            if (
+                                original_tool
+                                and hasattr(original_tool, "cache_function")
+                                and original_tool.cache_function
+                            ):
                                 should_cache = original_tool.cache_function(
                                     args_dict, raw_result
                                 )
@@ -764,34 +696,10 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
                                 error=e,
                             ),
                         )
-            elif max_usage_reached and original_tool:
+            elif max_usage_reached:
                 # Return error message when max usage limit is reached
                 result = f"Tool '{func_name}' has reached its usage limit of {original_tool.max_usage_count} times and cannot be used anymore."
 
-            # Execute after_tool_call hooks (even if blocked, to allow logging/monitoring)
-            after_hook_context = ToolCallHookContext(
-                tool_name=func_name,
-                tool_input=args_dict,
-                tool=structured_tool,  # type: ignore[arg-type]
-                agent=self.agent,
-                task=self.task,
-                crew=self.crew,
-                tool_result=result,
-            )
-            after_hooks = get_after_tool_call_hooks()
-            try:
-                for after_hook in after_hooks:
-                    after_hook_result = after_hook(after_hook_context)
-                    if after_hook_result is not None:
-                        result = after_hook_result
-                        after_hook_context.tool_result = result
-            except Exception as hook_error:
-                if self.agent.verbose:
-                    self._printer.print(
-                        content=f"Error in after_tool_call hook: {hook_error}",
-                        color="red",
-                    )
-
             # Emit tool usage finished event
             crewai_event_bus.emit(
                 self,
@@ -838,6 +746,15 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
                 self.state.is_finished = True
                 return "tool_result_is_final"
 
+        # Add reflection prompt once after all tools in the batch
+        reasoning_prompt = self._i18n.slice("post_tool_reasoning")
+
+        reasoning_message: LLMMessage = {
+            "role": "user",
+            "content": reasoning_prompt,
+        }
+        self.state.messages.append(reasoning_message)
+
         return "native_tool_completed"
 
     def _extract_tool_name(self, tool_call: Any) -> str:
@@ -916,17 +833,12 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
     @listen("parser_error")
     def recover_from_parser_error(self) -> Literal["initialized"]:
         """Recover from output parser errors and retry."""
-        if not self._last_parser_error:
-            self.state.iterations += 1
-            return "initialized"
-
         formatted_answer = handle_output_parser_exception(
             e=self._last_parser_error,
             messages=list(self.state.messages),
             iterations=self.state.iterations,
             log_error_after=self.log_error_after,
             printer=self._printer,
-            verbose=self.agent.verbose,
         )
 
         if formatted_answer:
@@ -946,7 +858,6 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
             llm=self.llm,
             callbacks=self.callbacks,
             i18n=self._i18n,
-            verbose=self.agent.verbose,
         )
 
         self.state.iterations += 1
@@ -1038,7 +949,7 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
             self._console.print(fail_text)
             raise
         except Exception as e:
-            handle_unknown_error(self._printer, e, verbose=self.agent.verbose)
+            handle_unknown_error(self._printer, e)
             raise
         finally:
             self._is_executing = False
@@ -1123,7 +1034,7 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
             self._console.print(fail_text)
             raise
         except Exception as e:
-            handle_unknown_error(self._printer, e, verbose=self.agent.verbose)
+            handle_unknown_error(self._printer, e)
             raise
         finally:
             self._is_executing = False
@@ -1319,12 +1230,7 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
         Returns:
             Final answer after feedback.
         """
-        output_str = (
-            str(formatted_answer.output)
-            if isinstance(formatted_answer.output, BaseModel)
-            else formatted_answer.output
-        )
-        human_feedback = self._ask_human_input(output_str)
+        human_feedback = self._ask_human_input(formatted_answer.output)
 
         if self._is_training_mode():
             return self._handle_training_feedback(formatted_answer, human_feedback)
@@ -1396,12 +1302,7 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
                 self.state.ask_for_human_input = False
             else:
                 answer = self._process_feedback_iteration(feedback)
-                output_str = (
-                    str(answer.output)
-                    if isinstance(answer.output, BaseModel)
-                    else answer.output
-                )
-                feedback = self._ask_human_input(output_str)
+                feedback = self._ask_human_input(answer.output)
 
         return answer
 

lib/crewai/src/crewai/flow/async_feedback/__init__.py

@@ -8,13 +8,11 @@ Example:
     from crewai.flow import Flow, start, human_feedback
     from crewai.flow.async_feedback import HumanFeedbackProvider, HumanFeedbackPending
 
-
     class SlackProvider(HumanFeedbackProvider):
         def request_feedback(self, context, flow):
             self.send_slack_notification(context)
             raise HumanFeedbackPending(context=context)
 
-
     class MyFlow(Flow):
         @start()
         @human_feedback(
@@ -28,13 +26,12 @@ Example:
     ```
 """
 
-from crewai.flow.async_feedback.providers import ConsoleProvider
 from crewai.flow.async_feedback.types import (
     HumanFeedbackPending,
     HumanFeedbackProvider,
     PendingFeedbackContext,
 )
-
+from crewai.flow.async_feedback.providers import ConsoleProvider
 
 __all__ = [
     "ConsoleProvider",

lib/crewai/src/crewai/flow/async_feedback/providers.py

@@ -6,11 +6,10 @@ provider that collects feedback via console input.
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING
 
 from crewai.flow.async_feedback.types import PendingFeedbackContext
 
-
 if TYPE_CHECKING:
     from crewai.flow.flow import Flow
 
@@ -28,7 +27,6 @@ class ConsoleProvider:
         ```python
         from crewai.flow.async_feedback import ConsoleProvider
 
-
         # Explicitly use console provider
         @human_feedback(
             message="Review this:",
@@ -51,7 +49,7 @@ class ConsoleProvider:
     def request_feedback(
         self,
         context: PendingFeedbackContext,
-        flow: Flow[Any],
+        flow: Flow,
     ) -> str:
         """Request feedback via console input (blocking).
 

lib/crewai/src/crewai/flow/async_feedback/types.py

@@ -10,7 +10,6 @@ from dataclasses import dataclass, field
 from datetime import datetime
 from typing import TYPE_CHECKING, Any, Protocol, runtime_checkable
 
-
 if TYPE_CHECKING:
     from crewai.flow.flow import Flow
 
@@ -156,7 +155,7 @@ class HumanFeedbackPending(Exception):  # noqa: N818 - Not an error, a control f
                     callback_info={
                         "slack_channel": "#reviews",
                         "thread_id": ticket_id,
-                    },
+                    }
                 )
         ```
     """
@@ -233,7 +232,7 @@ class HumanFeedbackProvider(Protocol):
                     callback_info={
                         "channel": self.channel,
                         "thread_id": thread_id,
-                    },
+                    }
                 )
         ```
     """
@@ -241,7 +240,7 @@ class HumanFeedbackProvider(Protocol):
     def request_feedback(
         self,
         context: PendingFeedbackContext,
-        flow: Flow[Any],
+        flow: Flow,
     ) -> str:
         """Request feedback from a human.
 

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

@@ -1,5 +1,4 @@
 from typing import Final, Literal
 
-
 AND_CONDITION: Final[Literal["AND"]] = "AND"
 OR_CONDITION: Final[Literal["OR"]] = "OR"

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

@@ -58,7 +58,6 @@ from crewai.events.types.flow_events import (
     MethodExecutionStartedEvent,
 )
 from crewai.flow.constants import AND_CONDITION, OR_CONDITION
-from crewai.flow.flow_context import current_flow_id, current_flow_request_id
 from crewai.flow.flow_wrappers import (
     FlowCondition,
     FlowConditions,
@@ -513,17 +512,11 @@ class FlowMeta(type):
                         and attr_value.__is_router__
                     ):
                         routers.add(attr_name)
-                        if (
-                            hasattr(attr_value, "__router_paths__")
-                            and attr_value.__router_paths__
-                        ):
-                            router_paths[attr_name] = attr_value.__router_paths__
+                        possible_returns = get_possible_return_constants(attr_value)
+                        if possible_returns:
+                            router_paths[attr_name] = possible_returns
                         else:
-                            possible_returns = get_possible_return_constants(attr_value)
-                            if possible_returns:
-                                router_paths[attr_name] = possible_returns
-                            else:
-                                router_paths[attr_name] = []
+                            router_paths[attr_name] = []
 
                 # Handle start methods that are also routers (e.g., @human_feedback with emit)
                 if (
@@ -1547,13 +1540,6 @@ class Flow(Generic[T], metaclass=FlowMeta):
         ctx = baggage.set_baggage("flow_input_files", input_files or {}, context=ctx)
         flow_token = attach(ctx)
 
-        flow_id_token = None
-        request_id_token = None
-        if current_flow_id.get() is None:
-            flow_id_token = current_flow_id.set(self.flow_id)
-        if current_flow_request_id.get() is None:
-            request_id_token = current_flow_request_id.set(self.flow_id)
-
         try:
             # Reset flow state for fresh execution unless restoring from persistence
             is_restoring = inputs and "id" in inputs and self._persistence is not None
@@ -1731,10 +1717,6 @@ class Flow(Generic[T], metaclass=FlowMeta):
 
             return final_output
         finally:
-            if request_id_token is not None:
-                current_flow_request_id.reset(request_id_token)
-            if flow_id_token is not None:
-                current_flow_id.reset(flow_id_token)
             detach(flow_token)
 
     async def akickoff(

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

@@ -8,7 +8,6 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
-
 if TYPE_CHECKING:
     from crewai.flow.async_feedback.types import HumanFeedbackProvider
 

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

@@ -1,16 +0,0 @@
-"""Flow execution context management.
-
-This module provides context variables for tracking flow execution state across
-async boundaries and nested function calls.
-"""
-
-import contextvars
-
-
-current_flow_request_id: contextvars.ContextVar[str | None] = contextvars.ContextVar(
-    "flow_request_id", default=None
-)
-
-current_flow_id: contextvars.ContextVar[str | None] = contextvars.ContextVar(
-    "flow_id", default=None
-)

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

@@ -1,22 +1,46 @@
-from pydantic import BaseModel, model_validator
+import inspect
+from typing import Any
+
+from pydantic import BaseModel, Field, InstanceOf, model_validator
 from typing_extensions import Self
 
-from crewai.flow.flow_context import current_flow_id, current_flow_request_id
+from crewai.flow.flow import Flow
 
 
 class FlowTrackable(BaseModel):
-    """Mixin that tracks flow execution context for objects created within flows.
+    """Mixin that tracks the Flow instance that instantiated the object, e.g. a
+    Flow instance that created a Crew or Agent.
 
-    When a Crew or Agent is instantiated inside a flow execution, this mixin
-    automatically captures the flow ID and request ID from context variables,
-    enabling proper tracking and association with the parent flow execution.
+    Automatically finds and stores a reference to the parent Flow instance by
+    inspecting the call stack.
     """
 
+    parent_flow: InstanceOf[Flow[Any]] | None = Field(
+        default=None,
+        description="The parent flow of the instance, if it was created inside a flow.",
+    )
+
     @model_validator(mode="after")
-    def _set_flow_context(self) -> Self:
-        request_id = current_flow_request_id.get()
-        if request_id:
-            self._request_id = request_id
-            self._flow_id = current_flow_id.get()
+    def _set_parent_flow(self) -> Self:
+        max_depth = 8
+        frame = inspect.currentframe()
+
+        try:
+            if frame is None:
+                return self
+
+            frame = frame.f_back
+            for _ in range(max_depth):
+                if frame is None:
+                    break
+
+                candidate = frame.f_locals.get("self")
+                if isinstance(candidate, Flow):
+                    self.parent_flow = candidate
+                    break
+
+                frame = frame.f_back
+        finally:
+            del frame
 
         return self

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

@@ -11,7 +11,6 @@ Example (synchronous, default):
     ```python
     from crewai.flow import Flow, start, listen, human_feedback
 
-
     class ReviewFlow(Flow):
         @start()
         @human_feedback(
@@ -33,13 +32,11 @@ Example (asynchronous with custom provider):
     from crewai.flow import Flow, start, human_feedback
     from crewai.flow.async_feedback import HumanFeedbackProvider, HumanFeedbackPending
 
-
     class SlackProvider(HumanFeedbackProvider):
         def request_feedback(self, context, flow):
             self.send_notification(context)
             raise HumanFeedbackPending(context=context)
 
-
     class ReviewFlow(Flow):
         @start()
         @human_feedback(
@@ -232,7 +229,6 @@ def human_feedback(
         def review_document(self):
             return document_content
 
-
         @listen("approved")
         def publish(self):
             print(f"Publishing: {self.last_human_feedback.output}")
@@ -269,7 +265,7 @@ def human_feedback(
     def decorator(func: F) -> F:
         """Inner decorator that wraps the function."""
 
-        def _request_feedback(flow_instance: Flow[Any], method_output: Any) -> str:
+        def _request_feedback(flow_instance: Flow, method_output: Any) -> str:
             """Request feedback using provider or default console."""
             from crewai.flow.async_feedback.types import PendingFeedbackContext
 
@@ -295,16 +291,19 @@ def human_feedback(
                 effective_provider = flow_config.hitl_provider
 
             if effective_provider is not None:
+                # Use provider (may raise HumanFeedbackPending for async providers)
                 return effective_provider.request_feedback(context, flow_instance)
-            return flow_instance._request_human_feedback(
-                message=message,
-                output=method_output,
-                metadata=metadata,
-                emit=emit,
-            )
+            else:
+                # Use default console input (local development)
+                return flow_instance._request_human_feedback(
+                    message=message,
+                    output=method_output,
+                    metadata=metadata,
+                    emit=emit,
+                )
 
         def _process_feedback(
-            flow_instance: Flow[Any],
+            flow_instance: Flow,
             method_output: Any,
             raw_feedback: str,
         ) -> HumanFeedbackResult | str:
@@ -320,14 +319,12 @@ def human_feedback(
                     # No default and no feedback - use first outcome
                     collapsed_outcome = emit[0]
             elif emit:
-                if llm is not None:
-                    collapsed_outcome = flow_instance._collapse_to_outcome(
-                        feedback=raw_feedback,
-                        outcomes=emit,
-                        llm=llm,
-                    )
-                else:
-                    collapsed_outcome = emit[0]
+                # Collapse feedback to outcome using LLM
+                collapsed_outcome = flow_instance._collapse_to_outcome(
+                    feedback=raw_feedback,
+                    outcomes=emit,
+                    llm=llm,
+                )
 
             # Create result
             result = HumanFeedbackResult(
@@ -352,7 +349,7 @@ def human_feedback(
         if asyncio.iscoroutinefunction(func):
             # Async wrapper
             @wraps(func)
-            async def async_wrapper(self: Flow[Any], *args: Any, **kwargs: Any) -> Any:
+            async def async_wrapper(self: Flow, *args: Any, **kwargs: Any) -> Any:
                 # Execute the original method
                 method_output = await func(self, *args, **kwargs)
 
@@ -366,7 +363,7 @@ def human_feedback(
         else:
             # Sync wrapper
             @wraps(func)
-            def sync_wrapper(self: Flow[Any], *args: Any, **kwargs: Any) -> Any:
+            def sync_wrapper(self: Flow, *args: Any, **kwargs: Any) -> Any:
                 # Execute the original method
                 method_output = func(self, *args, **kwargs)
 
@@ -400,10 +397,11 @@ def human_feedback(
         )
         wrapper.__is_flow_method__ = True
 
+        # Make it a router if emit specified
         if emit:
             wrapper.__is_router__ = True
             wrapper.__router_paths__ = list(emit)
 
-        return wrapper  # type: ignore[no-any-return]
+        return wrapper  # type: ignore[return-value]
 
     return decorator

lib/crewai/src/crewai/flow/persistence/base.py

@@ -7,7 +7,6 @@ from typing import TYPE_CHECKING, Any
 
 from pydantic import BaseModel
 
-
 if TYPE_CHECKING:
     from crewai.flow.async_feedback.types import PendingFeedbackContext
 
@@ -104,3 +103,4 @@ class FlowPersistence(ABC):
         Args:
             flow_uuid: Unique identifier for the flow instance
         """
+        pass

lib/crewai/src/crewai/flow/persistence/decorators.py

@@ -118,20 +118,17 @@ class PersistenceDecorator:
                 )
             except Exception as e:
                 error_msg = LOG_MESSAGES["save_error"].format(method_name, str(e))
-                if verbose:
-                    cls._printer.print(error_msg, color="red")
+                cls._printer.print(error_msg, color="red")
                 logger.error(error_msg)
                 raise RuntimeError(f"State persistence failed: {e!s}") from e
         except AttributeError as e:
             error_msg = LOG_MESSAGES["state_missing"]
-            if verbose:
-                cls._printer.print(error_msg, color="red")
+            cls._printer.print(error_msg, color="red")
             logger.error(error_msg)
             raise ValueError(error_msg) from e
         except (TypeError, ValueError) as e:
             error_msg = LOG_MESSAGES["id_missing"]
-            if verbose:
-                cls._printer.print(error_msg, color="red")
+            cls._printer.print(error_msg, color="red")
             logger.error(error_msg)
             raise ValueError(error_msg) from e
 

lib/crewai/src/crewai/flow/persistence/sqlite.py

@@ -15,7 +15,6 @@ from pydantic import BaseModel
 from crewai.flow.persistence.base import FlowPersistence
 from crewai.utilities.paths import db_storage_path
 
-
 if TYPE_CHECKING:
     from crewai.flow.async_feedback.types import PendingFeedbackContext
 
@@ -177,8 +176,7 @@ class SQLiteFlowPersistence(FlowPersistence):
             row = cursor.fetchone()
 
         if row:
-            result = json.loads(row[0])
-            return result if isinstance(result, dict) else None
+            return json.loads(row[0])
         return None
 
     def save_pending_feedback(
@@ -198,6 +196,7 @@ class SQLiteFlowPersistence(FlowPersistence):
             state_data: Current state data
         """
         # Import here to avoid circular imports
+        from crewai.flow.async_feedback.types import PendingFeedbackContext
 
         # Convert state_data to dict
         if isinstance(state_data, BaseModel):

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

@@ -151,9 +151,7 @@ def _unwrap_function(function: Any) -> Any:
     return function
 
 
-def get_possible_return_constants(
-    function: Any, verbose: bool = True
-) -> list[str] | None:
+def get_possible_return_constants(function: Any) -> list[str] | None:
     """Extract possible string return values from a function using AST parsing.
 
     This function analyzes the source code of a router method to identify
@@ -180,11 +178,10 @@ def get_possible_return_constants(
         # Can't get source code
         return None
     except Exception as e:
-        if verbose:
-            _printer.print(
-                f"Error retrieving source code for function {function.__name__}: {e}",
-                color="red",
-            )
+        _printer.print(
+            f"Error retrieving source code for function {function.__name__}: {e}",
+            color="red",
+        )
         return None
 
     try:
@@ -193,28 +190,25 @@ def get_possible_return_constants(
         # Parse the source code into an AST
         code_ast = ast.parse(source)
     except IndentationError as e:
-        if verbose:
-            _printer.print(
-                f"IndentationError while parsing source code of {function.__name__}: {e}",
-                color="red",
-            )
-            _printer.print(f"Source code:\n{source}", color="yellow")
+        _printer.print(
+            f"IndentationError while parsing source code of {function.__name__}: {e}",
+            color="red",
+        )
+        _printer.print(f"Source code:\n{source}", color="yellow")
         return None
     except SyntaxError as e:
-        if verbose:
-            _printer.print(
-                f"SyntaxError while parsing source code of {function.__name__}: {e}",
-                color="red",
-            )
-            _printer.print(f"Source code:\n{source}", color="yellow")
+        _printer.print(
+            f"SyntaxError while parsing source code of {function.__name__}: {e}",
+            color="red",
+        )
+        _printer.print(f"Source code:\n{source}", color="yellow")
         return None
     except Exception as e:
-        if verbose:
-            _printer.print(
-                f"Unexpected error while parsing source code of {function.__name__}: {e}",
-                color="red",
-            )
-            _printer.print(f"Source code:\n{source}", color="yellow")
+        _printer.print(
+            f"Unexpected error while parsing source code of {function.__name__}: {e}",
+            color="red",
+        )
+        _printer.print(f"Source code:\n{source}", color="yellow")
         return None
 
     return_values: set[str] = set()
@@ -394,17 +388,15 @@ def get_possible_return_constants(
 
                 StateAttributeVisitor().visit(class_ast)
             except Exception as e:
-                if verbose:
-                    _printer.print(
-                        f"Could not analyze class context for {function.__name__}: {e}",
-                        color="yellow",
-                    )
+                _printer.print(
+                    f"Could not analyze class context for {function.__name__}: {e}",
+                    color="yellow",
+                )
     except Exception as e:
-        if verbose:
-            _printer.print(
-                f"Could not introspect class for {function.__name__}: {e}",
-                color="yellow",
-            )
+        _printer.print(
+            f"Could not introspect class for {function.__name__}: {e}",
+            color="yellow",
+        )
 
     VariableAssignmentVisitor().visit(code_ast)
     ReturnVisitor().visit(code_ast)

lib/crewai/src/crewai/flow/visualization/assets/interactive.js

@@ -1025,7 +1025,7 @@ class TriggeredByHighlighter {
 
           const isAndOrRouter = edge.dashes || edge.label === "AND";
           const highlightColor = isAndOrRouter
-            ? (edge.color?.color || "{{ CREWAI_ORANGE }}")
+            ? "{{ CREWAI_ORANGE }}"
             : getComputedStyle(document.documentElement).getPropertyValue('--edge-or-color').trim();
 
           const updateData = {
@@ -1080,7 +1080,7 @@ class TriggeredByHighlighter {
           // Keep the original edge color instead of turning gray
           const isAndOrRouter = edge.dashes || edge.label === "AND";
           const baseColor = isAndOrRouter
-            ? (edge.color?.color || "{{ CREWAI_ORANGE }}")
+            ? "{{ CREWAI_ORANGE }}"
             : getComputedStyle(document.documentElement).getPropertyValue('--edge-or-color').trim();
 
           // Convert color to rgba with opacity for vis.js
@@ -1142,7 +1142,7 @@ class TriggeredByHighlighter {
 
         const defaultColor =
           edge.dashes || edge.label === "AND"
-            ? (edge.color?.color || "{{ CREWAI_ORANGE }}")
+            ? "{{ CREWAI_ORANGE }}"
             : getComputedStyle(document.documentElement).getPropertyValue('--edge-or-color').trim();
         const currentOpacity = edge.opacity !== undefined ? edge.opacity : 1.0;
         const currentWidth =
@@ -1253,7 +1253,7 @@ class TriggeredByHighlighter {
 
         const defaultColor =
           edge.dashes || edge.label === "AND"
-            ? (edge.color?.color || "{{ CREWAI_ORANGE }}")
+            ? "{{ CREWAI_ORANGE }}"
             : getComputedStyle(document.documentElement).getPropertyValue('--edge-or-color').trim();
         const currentOpacity = edge.opacity !== undefined ? edge.opacity : 1.0;
         const currentWidth =
@@ -2370,7 +2370,7 @@ class NetworkManager {
       this.edges.forEach((edge) => {
         let edgeColor;
         if (edge.dashes || edge.label === "AND") {
-          edgeColor = edge.color?.color || "{{ CREWAI_ORANGE }}";
+          edgeColor = "{{ CREWAI_ORANGE }}";
         } else {
           edgeColor = orEdgeColor;
         }

lib/crewai/src/crewai/flow/visualization/builder.py

@@ -129,7 +129,7 @@ def _create_edges_from_condition(
     edges: list[StructureEdge] = []
 
     if isinstance(condition, str):
-        if condition in nodes and condition != target:
+        if condition in nodes:
             edges.append(
                 StructureEdge(
                     source=condition,
@@ -140,7 +140,7 @@ def _create_edges_from_condition(
             )
     elif callable(condition) and hasattr(condition, "__name__"):
         method_name = condition.__name__
-        if method_name in nodes and method_name != target:
+        if method_name in nodes:
             edges.append(
                 StructureEdge(
                     source=method_name,
@@ -163,7 +163,7 @@ def _create_edges_from_condition(
                     is_router_path=False,
                 )
                 for trigger in triggers
-                if trigger in nodes and trigger != target
+                if trigger in nodes
             )
         else:
             for sub_cond in conditions_list:
@@ -196,34 +196,9 @@ def build_flow_structure(flow: Flow[Any]) -> FlowStructure:
             node_metadata["type"] = "start"
             start_methods.append(method_name)
 
-        if (
-            hasattr(method, "__human_feedback_config__")
-            and method.__human_feedback_config__
-        ):
-            config = method.__human_feedback_config__
-            node_metadata["is_human_feedback"] = True
-            node_metadata["human_feedback_message"] = config.message
-
-            if config.emit:
-                node_metadata["human_feedback_emit"] = list(config.emit)
-
-            if config.llm:
-                llm_str = (
-                    config.llm
-                    if isinstance(config.llm, str)
-                    else str(type(config.llm).__name__)
-                )
-                node_metadata["human_feedback_llm"] = llm_str
-
-            if config.default_outcome:
-                node_metadata["human_feedback_default_outcome"] = config.default_outcome
-
         if hasattr(method, "__is_router__") and method.__is_router__:
             node_metadata["is_router"] = True
-            if "is_human_feedback" not in node_metadata:
-                node_metadata["type"] = "router"
-            else:
-                node_metadata["type"] = "human_feedback"
+            node_metadata["type"] = "router"
             router_methods.append(method_name)
 
             if method_name in flow._router_paths:
@@ -342,7 +317,7 @@ def build_flow_structure(flow: Flow[Any]) -> FlowStructure:
                     is_router_path=False,
                 )
                 for trigger_method in methods
-                if str(trigger_method) in nodes and str(trigger_method) != listener_name
+                if str(trigger_method) in nodes
             )
         elif is_flow_condition_dict(condition_data):
             edges.extend(

lib/crewai/src/crewai/flow/visualization/renderers/interactive.py

@@ -81,7 +81,6 @@ class JSExtension(Extension):
 
 
 CREWAI_ORANGE = "#FF5A50"
-HITL_BLUE = "#4A90E2"
 DARK_GRAY = "#333333"
 WHITE = "#FFFFFF"
 GRAY = "#666666"
@@ -226,7 +225,6 @@ def render_interactive(
     nodes_list: list[dict[str, Any]] = []
     for name, metadata in dag["nodes"].items():
         node_type: str = metadata.get("type", "listen")
-        is_human_feedback: bool = metadata.get("is_human_feedback", False)
 
         color_config: dict[str, Any]
         font_color: str
@@ -243,17 +241,6 @@ def render_interactive(
             }
             font_color = "var(--node-text-color)"
             border_width = 3
-        elif node_type == "human_feedback":
-            color_config = {
-                "background": "var(--node-bg-router)",
-                "border": HITL_BLUE,
-                "highlight": {
-                    "background": "var(--node-bg-router)",
-                    "border": HITL_BLUE,
-                },
-            }
-            font_color = "var(--node-text-color)"
-            border_width = 3
         elif node_type == "router":
             color_config = {
                 "background": "var(--node-bg-router)",
@@ -279,57 +266,16 @@ def render_interactive(
 
         title_parts: list[str] = []
 
-        display_type = node_type
-        type_badge_bg: str
-        if node_type == "human_feedback":
-            type_badge_bg = HITL_BLUE
-            display_type = "HITL"
-        elif node_type in ["start", "router"]:
-            type_badge_bg = CREWAI_ORANGE
-        else:
-            type_badge_bg = DARK_GRAY
-
+        type_badge_bg: str = (
+            CREWAI_ORANGE if node_type in ["start", "router"] else DARK_GRAY
+        )
         title_parts.append(f"""
             <div style="border-bottom: 1px solid rgba(102,102,102,0.15); padding-bottom: 8px; margin-bottom: 10px;">
                 <div style="font-size: 13px; font-weight: 700; color: {DARK_GRAY}; margin-bottom: 6px;">{name}</div>
-                <span style="display: inline-block; background: {type_badge_bg}; color: white; padding: 2px 8px; border-radius: 4px; font-size: 10px; font-weight: 600; text-transform: uppercase; letter-spacing: 0.5px;">{display_type}</span>
+                <span style="display: inline-block; background: {type_badge_bg}; color: white; padding: 2px 8px; border-radius: 4px; font-size: 10px; font-weight: 600; text-transform: uppercase; letter-spacing: 0.5px;">{node_type}</span>
             </div>
         """)
 
-        if is_human_feedback:
-            feedback_msg = metadata.get("human_feedback_message", "")
-            if feedback_msg:
-                title_parts.append(f"""
-                    <div style="margin-bottom: 8px;">
-                        <div style="font-size: 10px; text-transform: uppercase; color: {GRAY}; letter-spacing: 0.5px; margin-bottom: 4px; font-weight: 600;">👤 Human Feedback</div>
-                        <div style="background: rgba(74,144,226,0.08); padding: 6px 8px; border-radius: 4px; font-size: 11px; color: {DARK_GRAY}; border: 1px solid rgba(74,144,226,0.2); line-height: 1.4;">{feedback_msg}</div>
-                    </div>
-                """)
-
-            if metadata.get("human_feedback_emit"):
-                emit_options = metadata["human_feedback_emit"]
-                emit_items = "".join(
-                    [
-                        f'<li style="margin: 3px 0;"><code style="background: rgba(74,144,226,0.08); padding: 2px 6px; border-radius: 3px; font-size: 10px; color: {HITL_BLUE}; border: 1px solid rgba(74,144,226,0.2); font-weight: 600;">{opt}</code></li>'
-                        for opt in emit_options
-                    ]
-                )
-                title_parts.append(f"""
-                    <div style="margin-bottom: 8px;">
-                        <div style="font-size: 10px; text-transform: uppercase; color: {GRAY}; letter-spacing: 0.5px; margin-bottom: 4px; font-weight: 600;">Outcomes</div>
-                        <ul style="list-style: none; padding: 0; margin: 0;">{emit_items}</ul>
-                    </div>
-                """)
-
-            if metadata.get("human_feedback_llm"):
-                llm_model = metadata["human_feedback_llm"]
-                title_parts.append(f"""
-                    <div style="margin-bottom: 8px;">
-                        <div style="font-size: 10px; text-transform: uppercase; color: {GRAY}; letter-spacing: 0.5px; margin-bottom: 3px; font-weight: 600;">LLM</div>
-                        <span style="display: inline-block; background: rgba(102,102,102,0.08); padding: 3px 8px; border-radius: 4px; font-size: 10px; color: {DARK_GRAY}; border: 1px solid rgba(102,102,102,0.12);">{llm_model}</span>
-                    </div>
-                """)
-
         if metadata.get("condition_type"):
             condition = metadata["condition_type"]
             if condition == "AND":
@@ -363,7 +309,7 @@ def render_interactive(
                 </div>
             """)
 
-        if metadata.get("router_paths") and not is_human_feedback:
+        if metadata.get("router_paths"):
             paths = metadata["router_paths"]
             paths_items = "".join(
                 [
@@ -419,11 +365,7 @@ def render_interactive(
         edge_dashes: bool | list[int] = False
 
         if edge["is_router_path"]:
-            source_node = dag["nodes"].get(edge["source"], {})
-            if source_node.get("is_human_feedback", False):
-                edge_color = HITL_BLUE
-            else:
-                edge_color = CREWAI_ORANGE
+            edge_color = CREWAI_ORANGE
             edge_dashes = [15, 10]
             if "router_path_label" in edge:
                 edge_label = edge["router_path_label"]
@@ -475,7 +417,6 @@ def render_interactive(
     css_content = css_content.replace("'{{ DARK_GRAY }}'", DARK_GRAY)
     css_content = css_content.replace("'{{ GRAY }}'", GRAY)
     css_content = css_content.replace("'{{ CREWAI_ORANGE }}'", CREWAI_ORANGE)
-    css_content = css_content.replace("'{{ HITL_BLUE }}'", HITL_BLUE)
 
     css_output_path.write_text(css_content, encoding="utf-8")
 
@@ -489,7 +430,6 @@ def render_interactive(
     js_content = js_content.replace("{{ DARK_GRAY }}", DARK_GRAY)
     js_content = js_content.replace("{{ GRAY }}", GRAY)
     js_content = js_content.replace("{{ CREWAI_ORANGE }}", CREWAI_ORANGE)
-    js_content = js_content.replace("{{ HITL_BLUE }}", HITL_BLUE)
     js_content = js_content.replace("'{{ nodeData }}'", dag_nodes_json)
     js_content = js_content.replace("'{{ dagData }}'", dag_full_json)
     js_content = js_content.replace("'{{ nodes_list_json }}'", json.dumps(nodes_list))
@@ -501,7 +441,6 @@ def render_interactive(
 
     html_content = template.render(
         CREWAI_ORANGE=CREWAI_ORANGE,
-        HITL_BLUE=HITL_BLUE,
         DARK_GRAY=DARK_GRAY,
         WHITE=WHITE,
         GRAY=GRAY,

lib/crewai/src/crewai/flow/visualization/types.py

@@ -21,11 +21,6 @@ class NodeMetadata(TypedDict, total=False):
     class_signature: str
     class_name: str
     class_line_number: int
-    is_human_feedback: bool
-    human_feedback_message: str
-    human_feedback_emit: list[str]
-    human_feedback_llm: str
-    human_feedback_default_outcome: str
 
 
 class StructureEdge(TypedDict, total=False):

lib/crewai/src/crewai/hooks/llm_hooks.py

@@ -9,7 +9,6 @@ from crewai.utilities.printer import Printer
 
 if TYPE_CHECKING:
     from crewai.agents.crew_agent_executor import CrewAgentExecutor
-    from crewai.experimental.agent_executor import AgentExecutor
     from crewai.lite_agent import LiteAgent
     from crewai.llms.base_llm import BaseLLM
     from crewai.utilities.types import LLMMessage
@@ -42,7 +41,7 @@ class LLMCallHookContext:
             Can be modified by returning a new string from after_llm_call hook.
     """
 
-    executor: CrewAgentExecutor | AgentExecutor | LiteAgent | None
+    executor: CrewAgentExecutor | LiteAgent | None
     messages: list[LLMMessage]
     agent: Any
     task: Any
@@ -53,7 +52,7 @@ class LLMCallHookContext:
 
     def __init__(
         self,
-        executor: CrewAgentExecutor | AgentExecutor | LiteAgent | None = None,
+        executor: CrewAgentExecutor | LiteAgent | None = None,
         response: str | None = None,
         messages: list[LLMMessage] | None = None,
         llm: BaseLLM | str | Any | None = None,  # TODO: look into

lib/crewai/src/crewai/lite_agent.py

@@ -2,10 +2,8 @@ from __future__ import annotations
 
 import asyncio
 from collections.abc import Callable
-from functools import wraps
 import inspect
 import json
-from types import MethodType
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -32,8 +30,6 @@ from typing_extensions import Self
 if TYPE_CHECKING:
     from crewai_files import FileInput
 
-    from crewai.a2a.config import A2AClientConfig, A2AConfig, A2AServerConfig
-
 from crewai.agents.agent_builder.base_agent import BaseAgent
 from crewai.agents.agent_builder.utilities.base_token_process import TokenProcess
 from crewai.agents.cache.cache_handler import CacheHandler
@@ -76,93 +72,18 @@ from crewai.utilities.agent_utils import (
 from crewai.utilities.converter import (
     Converter,
     ConverterError,
+    generate_model_description,
 )
 from crewai.utilities.guardrail import process_guardrail
 from crewai.utilities.guardrail_types import GuardrailCallable, GuardrailType
 from crewai.utilities.i18n import I18N, get_i18n
 from crewai.utilities.llm_utils import create_llm
 from crewai.utilities.printer import Printer
-from crewai.utilities.pydantic_schema_utils import generate_model_description
 from crewai.utilities.token_counter_callback import TokenCalcHandler
 from crewai.utilities.tool_utils import execute_tool_and_check_finality
 from crewai.utilities.types import LLMMessage
 
 
-def _kickoff_with_a2a_support(
-    agent: LiteAgent,
-    original_kickoff: Callable[..., LiteAgentOutput],
-    messages: str | list[LLMMessage],
-    response_format: type[BaseModel] | None,
-    input_files: dict[str, FileInput] | None,
-    extension_registry: Any,
-) -> LiteAgentOutput:
-    """Wrap kickoff with A2A delegation using Task adapter.
-
-    Args:
-        agent: The LiteAgent instance.
-        original_kickoff: The original kickoff method.
-        messages: Input messages.
-        response_format: Optional response format.
-        input_files: Optional input files.
-        extension_registry: A2A extension registry.
-
-    Returns:
-        LiteAgentOutput from either local execution or A2A delegation.
-    """
-    from crewai.a2a.utils.response_model import get_a2a_agents_and_response_model
-    from crewai.a2a.wrapper import _execute_task_with_a2a
-    from crewai.task import Task
-
-    a2a_agents, agent_response_model = get_a2a_agents_and_response_model(agent.a2a)
-
-    if not a2a_agents:
-        return original_kickoff(messages, response_format, input_files)
-
-    if isinstance(messages, str):
-        description = messages
-    else:
-        content = next(
-            (m["content"] for m in reversed(messages) if m["role"] == "user"),
-            None,
-        )
-        description = content if isinstance(content, str) else ""
-
-    if not description:
-        return original_kickoff(messages, response_format, input_files)
-
-    fake_task = Task(
-        description=description,
-        agent=agent,
-        expected_output="Result from A2A delegation",
-        input_files=input_files or {},
-    )
-
-    def task_to_kickoff_adapter(
-        self: Any, task: Task, context: str | None, tools: list[Any] | None
-    ) -> str:
-        result = original_kickoff(messages, response_format, input_files)
-        return result.raw
-
-    result_str = _execute_task_with_a2a(
-        self=agent,  # type: ignore[arg-type]
-        a2a_agents=a2a_agents,
-        original_fn=task_to_kickoff_adapter,
-        task=fake_task,
-        agent_response_model=agent_response_model,
-        context=None,
-        tools=None,
-        extension_registry=extension_registry,
-    )
-
-    return LiteAgentOutput(
-        raw=result_str,
-        pydantic=None,
-        agent_role=agent.role,
-        usage_metrics=None,
-        messages=[],
-    )
-
-
 class LiteAgent(FlowTrackable, BaseModel):
     """
     A lightweight agent that can process messages and use tools.
@@ -233,17 +154,6 @@ class LiteAgent(FlowTrackable, BaseModel):
     guardrail_max_retries: int = Field(
         default=3, description="Maximum number of retries when guardrail fails"
     )
-    a2a: (
-        list[A2AConfig | A2AServerConfig | A2AClientConfig]
-        | A2AConfig
-        | A2AServerConfig
-        | A2AClientConfig
-        | None
-    ) = Field(
-        default=None,
-        description="A2A (Agent-to-Agent) configuration for delegating tasks to remote agents. "
-        "Can be a single A2AConfig/A2AClientConfig/A2AServerConfig, or a list of configurations.",
-    )
     tools_results: list[dict[str, Any]] = Field(
         default_factory=list, description="Results of the tools used by the agent."
     )
@@ -299,52 +209,6 @@ class LiteAgent(FlowTrackable, BaseModel):
 
         return self
 
-    @model_validator(mode="after")
-    def setup_a2a_support(self) -> Self:
-        """Setup A2A extensions and server methods if a2a config exists."""
-        if self.a2a:
-            from crewai.a2a.config import A2AClientConfig, A2AConfig
-            from crewai.a2a.extensions.registry import (
-                create_extension_registry_from_config,
-            )
-            from crewai.a2a.utils.agent_card import inject_a2a_server_methods
-
-            configs = self.a2a if isinstance(self.a2a, list) else [self.a2a]
-            client_configs = [
-                config
-                for config in configs
-                if isinstance(config, (A2AConfig, A2AClientConfig))
-            ]
-
-            extension_registry = (
-                create_extension_registry_from_config(client_configs)
-                if client_configs
-                else create_extension_registry_from_config([])
-            )
-            extension_registry.inject_all_tools(self)  # type: ignore[arg-type]
-            inject_a2a_server_methods(self)  # type: ignore[arg-type]
-
-            original_kickoff = self.kickoff
-
-            @wraps(original_kickoff)
-            def kickoff_with_a2a(
-                messages: str | list[LLMMessage],
-                response_format: type[BaseModel] | None = None,
-                input_files: dict[str, FileInput] | None = None,
-            ) -> LiteAgentOutput:
-                return _kickoff_with_a2a_support(
-                    self,
-                    original_kickoff,
-                    messages,
-                    response_format,
-                    input_files,
-                    extension_registry,
-                )
-
-            object.__setattr__(self, "kickoff", MethodType(kickoff_with_a2a, self))
-
-        return self
-
     @model_validator(mode="after")
     def ensure_guardrail_is_callable(self) -> Self:
         if callable(self.guardrail):
@@ -480,12 +344,11 @@ class LiteAgent(FlowTrackable, BaseModel):
             )
 
         except Exception as e:
-            if self.verbose:
-                self._printer.print(
-                    content="Agent failed to reach a final answer. This is likely a bug - please report it.",
-                    color="red",
-                )
-            handle_unknown_error(self._printer, e, verbose=self.verbose)
+            self._printer.print(
+                content="Agent failed to reach a final answer. This is likely a bug - please report it.",
+                color="red",
+            )
+            handle_unknown_error(self._printer, e)
             # Emit error event
             crewai_event_bus.emit(
                 self,
@@ -533,11 +396,10 @@ class LiteAgent(FlowTrackable, BaseModel):
                 if isinstance(result, BaseModel):
                     formatted_result = result
             except ConverterError as e:
-                if self.verbose:
-                    self._printer.print(
-                        content=f"Failed to parse output into response format after retries: {e.message}",
-                        color="yellow",
-                    )
+                self._printer.print(
+                    content=f"Failed to parse output into response format after retries: {e.message}",
+                    color="yellow",
+                )
 
         # Calculate token usage metrics
         if isinstance(self.llm, BaseLLM):
@@ -743,7 +605,6 @@ class LiteAgent(FlowTrackable, BaseModel):
                         messages=self._messages,
                         llm=cast(LLM, self.llm),
                         callbacks=self._callbacks,
-                        verbose=self.verbose,
                     )
 
                 enforce_rpm_limit(self.request_within_rpm_limit)
@@ -756,15 +617,12 @@ class LiteAgent(FlowTrackable, BaseModel):
                         printer=self._printer,
                         from_agent=self,
                         executor_context=self,
-                        verbose=self.verbose,
                     )
 
                 except Exception as e:
                     raise e
 
-                formatted_answer = process_llm_response(
-                    cast(str, answer), self.use_stop_words
-                )
+                formatted_answer = process_llm_response(answer, self.use_stop_words)
 
                 if isinstance(formatted_answer, AgentAction):
                     try:
@@ -788,18 +646,16 @@ class LiteAgent(FlowTrackable, BaseModel):
 
                 self._append_message(formatted_answer.text, role="assistant")
             except OutputParserError as e:  # noqa: PERF203
-                if self.verbose:
-                    self._printer.print(
-                        content="Failed to parse LLM output. Retrying...",
-                        color="yellow",
-                    )
+                self._printer.print(
+                    content="Failed to parse LLM output. Retrying...",
+                    color="yellow",
+                )
                 formatted_answer = handle_output_parser_exception(
                     e=e,
                     messages=self._messages,
                     iterations=self._iterations,
                     log_error_after=3,
                     printer=self._printer,
-                    verbose=self.verbose,
                 )
 
             except Exception as e:
@@ -814,10 +670,9 @@ class LiteAgent(FlowTrackable, BaseModel):
                         llm=cast(LLM, self.llm),
                         callbacks=self._callbacks,
                         i18n=self.i18n,
-                        verbose=self.verbose,
                     )
                     continue
-                handle_unknown_error(self._printer, e, verbose=self.verbose)
+                handle_unknown_error(self._printer, e)
                 raise e
 
             finally:
@@ -847,21 +702,3 @@ class LiteAgent(FlowTrackable, BaseModel):
     ) -> None:
         """Append a message to the message list with the given role."""
         self._messages.append(format_message_for_llm(text, role=role))
-
-
-try:
-    from crewai.a2a.config import (
-        A2AClientConfig as _A2AClientConfig,
-        A2AConfig as _A2AConfig,
-        A2AServerConfig as _A2AServerConfig,
-    )
-
-    LiteAgent.model_rebuild(
-        _types_namespace={
-            "A2AConfig": _A2AConfig,
-            "A2AClientConfig": _A2AClientConfig,
-            "A2AServerConfig": _A2AServerConfig,
-        }
-    )
-except ImportError:
-    pass

lib/crewai/src/crewai/llm.py

@@ -768,10 +768,6 @@ class LLM(BaseLLM):
 
                 # Extract content from the chunk
                 chunk_content = None
-                response_id = None
-
-                if hasattr(chunk,'id'):
-                    response_id = chunk.id
 
                 # Safely extract content from various chunk formats
                 try:
@@ -827,7 +823,6 @@ class LLM(BaseLLM):
                                         available_functions=available_functions,
                                         from_task=from_task,
                                         from_agent=from_agent,
-                                        response_id=response_id
                                     )
 
                                     if result is not None:
@@ -849,7 +844,6 @@ class LLM(BaseLLM):
                             from_task=from_task,
                             from_agent=from_agent,
                             call_type=LLMCallType.LLM_CALL,
-                            response_id=response_id
                         ),
                     )
             # --- 4) Fallback to non-streaming if no content received
@@ -1027,7 +1021,6 @@ class LLM(BaseLLM):
         available_functions: dict[str, Any] | None = None,
         from_task: Task | None = None,
         from_agent: Agent | None = None,
-        response_id: str | None = None,
     ) -> Any:
         for tool_call in tool_calls:
             current_tool_accumulator = accumulated_tool_args[tool_call.index]
@@ -1048,7 +1041,6 @@ class LLM(BaseLLM):
                     from_task=from_task,
                     from_agent=from_agent,
                     call_type=LLMCallType.TOOL_CALL,
-                    response_id=response_id
                 ),
             )
 
@@ -1410,13 +1402,11 @@ class LLM(BaseLLM):
 
         params["stream"] = True
         params["stream_options"] = {"include_usage": True}
-        response_id = None
 
         try:
             async for chunk in await litellm.acompletion(**params):
                 chunk_count += 1
                 chunk_content = None
-                response_id = chunk.id if hasattr(chunk, "id") else None
 
                 try:
                     choices = None
@@ -1476,7 +1466,6 @@ class LLM(BaseLLM):
                             chunk=chunk_content,
                             from_task=from_task,
                             from_agent=from_agent,
-                            response_id=response_id
                         ),
                     )
 
@@ -1514,7 +1503,6 @@ class LLM(BaseLLM):
                         available_functions=available_functions,
                         from_task=from_task,
                         from_agent=from_agent,
-                        response_id=response_id,
                     )
                     if result is not None:
                         return result

lib/crewai/src/crewai/llms/base_llm.py

@@ -404,7 +404,6 @@ class BaseLLM(ABC):
         from_agent: Agent | None = None,
         tool_call: dict[str, Any] | None = None,
         call_type: LLMCallType | None = None,
-        response_id: str | None = None,
     ) -> None:
         """Emit stream chunk event.
 
@@ -414,7 +413,6 @@ class BaseLLM(ABC):
             from_agent: The agent that initiated the call.
             tool_call: Tool call information if this is a tool call chunk.
             call_type: The type of LLM call (LLM_CALL or TOOL_CALL).
-            response_id: Unique ID for a particular LLM response, chunks have same response_id.
         """
         if not hasattr(crewai_event_bus, "emit"):
             raise ValueError("crewai_event_bus does not have an emit method") from None
@@ -427,7 +425,6 @@ class BaseLLM(ABC):
                 from_task=from_task,
                 from_agent=from_agent,
                 call_type=call_type,
-                response_id=response_id,
             ),
         )
 
@@ -497,7 +494,7 @@ class BaseLLM(ABC):
                 from_agent=from_agent,
             )
 
-            return str(result) if not isinstance(result, str) else result
+            return result
 
         except Exception as e:
             error_msg = f"Error executing function '{function_name}': {e!s}"
@@ -737,25 +734,22 @@ class BaseLLM(ABC):
             task=None,
             crew=None,
         )
-        verbose = getattr(from_agent, "verbose", True) if from_agent else True
         printer = Printer()
 
         try:
             for hook in before_hooks:
                 result = hook(hook_context)
                 if result is False:
-                    if verbose:
-                        printer.print(
-                            content="LLM call blocked by before_llm_call hook",
-                            color="yellow",
-                        )
+                    printer.print(
+                        content="LLM call blocked by before_llm_call hook",
+                        color="yellow",
+                    )
                     return False
         except Exception as e:
-            if verbose:
-                printer.print(
-                    content=f"Error in before_llm_call hook: {e}",
-                    color="yellow",
-                )
+            printer.print(
+                content=f"Error in before_llm_call hook: {e}",
+                color="yellow",
+            )
 
         return True
 
@@ -808,7 +802,6 @@ class BaseLLM(ABC):
             crew=None,
             response=response,
         )
-        verbose = getattr(from_agent, "verbose", True) if from_agent else True
         printer = Printer()
         modified_response = response
 
@@ -819,10 +812,9 @@ class BaseLLM(ABC):
                     modified_response = result
                     hook_context.response = modified_response
         except Exception as e:
-            if verbose:
-                printer.print(
-                    content=f"Error in after_llm_call hook: {e}",
-                    color="yellow",
-                )
+            printer.print(
+                content=f"Error in after_llm_call hook: {e}",
+                color="yellow",
+            )
 
         return modified_response

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

@@ -3,8 +3,9 @@ from __future__ import annotations
 import json
 import logging
 import os
-from typing import TYPE_CHECKING, Any, Final, Literal, TypeGuard, cast
+from typing import TYPE_CHECKING, Any, Literal, cast
 
+from anthropic.types import ThinkingBlock
 from pydantic import BaseModel
 
 from crewai.events.types.llm_events import LLMCallType
@@ -21,9 +22,8 @@ if TYPE_CHECKING:
     from crewai.llms.hooks.base import BaseInterceptor
 
 try:
-    from anthropic import Anthropic, AsyncAnthropic, transform_schema
+    from anthropic import Anthropic, AsyncAnthropic
     from anthropic.types import Message, TextBlock, ThinkingBlock, ToolUseBlock
-    from anthropic.types.beta import BetaMessage, BetaTextBlock, BetaToolUseBlock
     import httpx
 except ImportError:
     raise ImportError(
@@ -31,62 +31,7 @@ except ImportError:
     ) from None
 
 
-ANTHROPIC_FILES_API_BETA: Final = "files-api-2025-04-14"
-ANTHROPIC_STRUCTURED_OUTPUTS_BETA: Final = "structured-outputs-2025-11-13"
-
-NATIVE_STRUCTURED_OUTPUT_MODELS: Final[
-    tuple[
-        Literal["claude-sonnet-4-5"],
-        Literal["claude-sonnet-4.5"],
-        Literal["claude-opus-4-5"],
-        Literal["claude-opus-4.5"],
-        Literal["claude-opus-4-1"],
-        Literal["claude-opus-4.1"],
-        Literal["claude-haiku-4-5"],
-        Literal["claude-haiku-4.5"],
-    ]
-] = (
-    "claude-sonnet-4-5",
-    "claude-sonnet-4.5",
-    "claude-opus-4-5",
-    "claude-opus-4.5",
-    "claude-opus-4-1",
-    "claude-opus-4.1",
-    "claude-haiku-4-5",
-    "claude-haiku-4.5",
-)
-
-
-def _supports_native_structured_outputs(model: str) -> bool:
-    """Check if the model supports native structured outputs.
-
-    Native structured outputs are only available for Claude 4.5 models
-    (Sonnet 4.5, Opus 4.5, Opus 4.1, Haiku 4.5).
-    Other models require the tool-based fallback approach.
-
-    Args:
-        model: The model name/identifier.
-
-    Returns:
-        True if the model supports native structured outputs.
-    """
-    model_lower = model.lower()
-    return any(prefix in model_lower for prefix in NATIVE_STRUCTURED_OUTPUT_MODELS)
-
-
-def _is_pydantic_model_class(obj: Any) -> TypeGuard[type[BaseModel]]:
-    """Check if an object is a Pydantic model class.
-
-    This distinguishes between Pydantic model classes that support structured
-    outputs (have model_json_schema) and plain dicts like {"type": "json_object"}.
-
-    Args:
-        obj: The object to check.
-
-    Returns:
-        True if obj is a Pydantic model class.
-    """
-    return isinstance(obj, type) and issubclass(obj, BaseModel)
+ANTHROPIC_FILES_API_BETA = "files-api-2025-04-14"
 
 
 def _contains_file_id_reference(messages: list[dict[str, Any]]) -> bool:
@@ -139,7 +84,6 @@ class AnthropicCompletion(BaseLLM):
         client_params: dict[str, Any] | None = None,
         interceptor: BaseInterceptor[httpx.Request, httpx.Response] | None = None,
         thinking: AnthropicThinkingConfig | None = None,
-        response_format: type[BaseModel] | None = None,
         **kwargs: Any,
     ):
         """Initialize Anthropic chat completion client.
@@ -157,8 +101,6 @@ class AnthropicCompletion(BaseLLM):
             stream: Enable streaming responses
             client_params: Additional parameters for the Anthropic client
             interceptor: HTTP interceptor for modifying requests/responses at transport level.
-            response_format: Pydantic model for structured output. When provided, responses
-                will be validated against this model schema.
             **kwargs: Additional parameters
         """
         super().__init__(
@@ -189,7 +131,6 @@ class AnthropicCompletion(BaseLLM):
         self.stop_sequences = stop_sequences or []
         self.thinking = thinking
         self.previous_thinking_blocks: list[ThinkingBlock] = []
-        self.response_format = response_format
         # Model-specific settings
         self.is_claude_3 = "claude-3" in model.lower()
         self.supports_tools = True
@@ -290,8 +231,6 @@ class AnthropicCompletion(BaseLLM):
                 formatted_messages, system_message, tools
             )
 
-            effective_response_model = response_model or self.response_format
-
             # Handle streaming vs non-streaming
             if self.stream:
                 return self._handle_streaming_completion(
@@ -299,7 +238,7 @@ class AnthropicCompletion(BaseLLM):
                     available_functions,
                     from_task,
                     from_agent,
-                    effective_response_model,
+                    response_model,
                 )
 
             return self._handle_completion(
@@ -307,7 +246,7 @@ class AnthropicCompletion(BaseLLM):
                 available_functions,
                 from_task,
                 from_agent,
-                effective_response_model,
+                response_model,
             )
 
         except Exception as e:
@@ -337,7 +276,6 @@ class AnthropicCompletion(BaseLLM):
             available_functions: Available functions for tool calling
             from_task: Task that initiated the call
             from_agent: Agent that initiated the call
-            response_model: Optional response model.
 
         Returns:
             Chat completion response or tool call result
@@ -360,15 +298,13 @@ class AnthropicCompletion(BaseLLM):
                 formatted_messages, system_message, tools
             )
 
-            effective_response_model = response_model or self.response_format
-
             if self.stream:
                 return await self._ahandle_streaming_completion(
                     completion_params,
                     available_functions,
                     from_task,
                     from_agent,
-                    effective_response_model,
+                    response_model,
                 )
 
             return await self._ahandle_completion(
@@ -376,7 +312,7 @@ class AnthropicCompletion(BaseLLM):
                 available_functions,
                 from_task,
                 from_agent,
-                effective_response_model,
+                response_model,
             )
 
         except Exception as e:
@@ -629,40 +565,22 @@ class AnthropicCompletion(BaseLLM):
         response_model: type[BaseModel] | None = None,
     ) -> str | Any:
         """Handle non-streaming message completion."""
+        if response_model:
+            structured_tool = {
+                "name": "structured_output",
+                "description": "Returns structured data according to the schema",
+                "input_schema": response_model.model_json_schema(),
+            }
+
+            params["tools"] = [structured_tool]
+            params["tool_choice"] = {"type": "tool", "name": "structured_output"}
+
         uses_file_api = _contains_file_id_reference(params.get("messages", []))
-        betas: list[str] = []
-        use_native_structured_output = False
-
-        if uses_file_api:
-            betas.append(ANTHROPIC_FILES_API_BETA)
-
-        extra_body: dict[str, Any] | None = None
-        if _is_pydantic_model_class(response_model):
-            schema = transform_schema(response_model.model_json_schema())
-            if _supports_native_structured_outputs(self.model):
-                use_native_structured_output = True
-                betas.append(ANTHROPIC_STRUCTURED_OUTPUTS_BETA)
-                extra_body = {
-                    "output_format": {
-                        "type": "json_schema",
-                        "schema": schema,
-                    }
-                }
-            else:
-                structured_tool = {
-                    "name": "structured_output",
-                    "description": "Output the structured response",
-                    "input_schema": schema,
-                }
-                params["tools"] = [structured_tool]
-                params["tool_choice"] = {"type": "tool", "name": "structured_output"}
 
         try:
-            if betas:
-                params["betas"] = betas
-                response = self.client.beta.messages.create(
-                    **params, extra_body=extra_body
-                )
+            if uses_file_api:
+                params["betas"] = [ANTHROPIC_FILES_API_BETA]
+                response = self.client.beta.messages.create(**params)
             else:
                 response = self.client.messages.create(**params)
 
@@ -675,41 +593,27 @@ class AnthropicCompletion(BaseLLM):
         usage = self._extract_anthropic_token_usage(response)
         self._track_token_usage_internal(usage)
 
-        if _is_pydantic_model_class(response_model) and response.content:
-            if use_native_structured_output:
-                for block in response.content:
-                    if isinstance(block, (TextBlock, BetaTextBlock)):
-                        structured_data = response_model.model_validate_json(block.text)
-                        self._emit_call_completed_event(
-                            response=structured_data.model_dump_json(),
-                            call_type=LLMCallType.LLM_CALL,
-                            from_task=from_task,
-                            from_agent=from_agent,
-                            messages=params["messages"],
-                        )
-                        return structured_data
-            else:
-                for block in response.content:
-                    if (
-                        isinstance(block, (ToolUseBlock, BetaToolUseBlock))
-                        and block.name == "structured_output"
-                    ):
-                        structured_data = response_model.model_validate(block.input)
-                        self._emit_call_completed_event(
-                            response=structured_data.model_dump_json(),
-                            call_type=LLMCallType.LLM_CALL,
-                            from_task=from_task,
-                            from_agent=from_agent,
-                            messages=params["messages"],
-                        )
-                        return structured_data
+        if response_model and response.content:
+            tool_uses = [
+                block for block in response.content if isinstance(block, ToolUseBlock)
+            ]
+            if tool_uses and tool_uses[0].name == "structured_output":
+                structured_data = tool_uses[0].input
+                structured_json = json.dumps(structured_data)
+                self._emit_call_completed_event(
+                    response=structured_json,
+                    call_type=LLMCallType.LLM_CALL,
+                    from_task=from_task,
+                    from_agent=from_agent,
+                    messages=params["messages"],
+                )
+
+                return structured_json
 
         # Check if Claude wants to use tools
         if response.content:
             tool_uses = [
-                block
-                for block in response.content
-                if isinstance(block, (ToolUseBlock, BetaToolUseBlock))
+                block for block in response.content if isinstance(block, ToolUseBlock)
             ]
 
             if tool_uses:
@@ -774,31 +678,17 @@ class AnthropicCompletion(BaseLLM):
         from_task: Any | None = None,
         from_agent: Any | None = None,
         response_model: type[BaseModel] | None = None,
-    ) -> str | Any:
+    ) -> str:
         """Handle streaming message completion."""
-        betas: list[str] = []
-        use_native_structured_output = False
+        if response_model:
+            structured_tool = {
+                "name": "structured_output",
+                "description": "Returns structured data according to the schema",
+                "input_schema": response_model.model_json_schema(),
+            }
 
-        extra_body: dict[str, Any] | None = None
-        if _is_pydantic_model_class(response_model):
-            schema = transform_schema(response_model.model_json_schema())
-            if _supports_native_structured_outputs(self.model):
-                use_native_structured_output = True
-                betas.append(ANTHROPIC_STRUCTURED_OUTPUTS_BETA)
-                extra_body = {
-                    "output_format": {
-                        "type": "json_schema",
-                        "schema": schema,
-                    }
-                }
-            else:
-                structured_tool = {
-                    "name": "structured_output",
-                    "description": "Output the structured response",
-                    "input_schema": schema,
-                }
-                params["tools"] = [structured_tool]
-                params["tool_choice"] = {"type": "tool", "name": "structured_output"}
+            params["tools"] = [structured_tool]
+            params["tool_choice"] = {"type": "tool", "name": "structured_output"}
 
         full_response = ""
 
@@ -806,22 +696,11 @@ class AnthropicCompletion(BaseLLM):
         # (the SDK sets it internally)
         stream_params = {k: v for k, v in params.items() if k != "stream"}
 
-        if betas:
-            stream_params["betas"] = betas
-
         current_tool_calls: dict[int, dict[str, Any]] = {}
 
-        stream_context = (
-            self.client.beta.messages.stream(**stream_params, extra_body=extra_body)
-            if betas
-            else self.client.messages.stream(**stream_params)
-        )
-        with stream_context as stream:
-            response_id = None
+        # Make streaming API call
+        with self.client.messages.stream(**stream_params) as stream:
             for event in stream:
-                if hasattr(event, "message") and hasattr(event.message, "id"):
-                    response_id = event.message.id
-
                 if hasattr(event, "delta") and hasattr(event.delta, "text"):
                     text_delta = event.delta.text
                     full_response += text_delta
@@ -829,7 +708,6 @@ class AnthropicCompletion(BaseLLM):
                         chunk=text_delta,
                         from_task=from_task,
                         from_agent=from_agent,
-                        response_id=response_id,
                     )
 
                 if event.type == "content_block_start":
@@ -856,7 +734,6 @@ class AnthropicCompletion(BaseLLM):
                                 "index": block_index,
                             },
                             call_type=LLMCallType.TOOL_CALL,
-                            response_id=response_id,
                         )
                 elif event.type == "content_block_delta":
                     if event.delta.type == "input_json_delta":
@@ -880,10 +757,9 @@ class AnthropicCompletion(BaseLLM):
                                     "index": block_index,
                                 },
                                 call_type=LLMCallType.TOOL_CALL,
-                                response_id=response_id,
                             )
 
-            final_message = stream.get_final_message()
+            final_message: Message = stream.get_final_message()
 
         thinking_blocks: list[ThinkingBlock] = []
         if final_message.content:
@@ -898,43 +774,39 @@ class AnthropicCompletion(BaseLLM):
         usage = self._extract_anthropic_token_usage(final_message)
         self._track_token_usage_internal(usage)
 
-        if _is_pydantic_model_class(response_model):
-            if use_native_structured_output:
-                structured_data = response_model.model_validate_json(full_response)
+        if response_model and final_message.content:
+            tool_uses = [
+                block
+                for block in final_message.content
+                if isinstance(block, ToolUseBlock)
+            ]
+            if tool_uses and tool_uses[0].name == "structured_output":
+                structured_data = tool_uses[0].input
+                structured_json = json.dumps(structured_data)
+
                 self._emit_call_completed_event(
-                    response=structured_data.model_dump_json(),
+                    response=structured_json,
                     call_type=LLMCallType.LLM_CALL,
                     from_task=from_task,
                     from_agent=from_agent,
                     messages=params["messages"],
                 )
-                return structured_data
-            for block in final_message.content:
-                if (
-                    isinstance(block, ToolUseBlock)
-                    and block.name == "structured_output"
-                ):
-                    structured_data = response_model.model_validate(block.input)
-                    self._emit_call_completed_event(
-                        response=structured_data.model_dump_json(),
-                        call_type=LLMCallType.LLM_CALL,
-                        from_task=from_task,
-                        from_agent=from_agent,
-                        messages=params["messages"],
-                    )
-                    return structured_data
+
+                return structured_json
 
         if final_message.content:
             tool_uses = [
                 block
                 for block in final_message.content
-                if isinstance(block, (ToolUseBlock, BetaToolUseBlock))
+                if isinstance(block, ToolUseBlock)
             ]
 
             if tool_uses:
+                # If no available_functions, return tool calls for executor to handle
                 if not available_functions:
                     return list(tool_uses)
 
+                # Handle tool use conversation flow internally
                 return self._handle_tool_use_conversation(
                     final_message,
                     tool_uses,
@@ -944,8 +816,10 @@ class AnthropicCompletion(BaseLLM):
                     from_agent,
                 )
 
+        # Apply stop words to full response
         full_response = self._apply_stop_words(full_response)
 
+        # Emit completion event and return full response
         self._emit_call_completed_event(
             response=full_response,
             call_type=LLMCallType.LLM_CALL,
@@ -960,7 +834,7 @@ class AnthropicCompletion(BaseLLM):
 
     def _execute_tools_and_collect_results(
         self,
-        tool_uses: list[ToolUseBlock | BetaToolUseBlock],
+        tool_uses: list[ToolUseBlock],
         available_functions: dict[str, Any],
         from_task: Any | None = None,
         from_agent: Any | None = None,
@@ -968,7 +842,7 @@ class AnthropicCompletion(BaseLLM):
         """Execute tools and collect results in Anthropic format.
 
         Args:
-            tool_uses: List of tool use blocks from Claude's response (regular or beta API)
+            tool_uses: List of tool use blocks from Claude's response
             available_functions: Available functions for tool calling
             from_task: Task that initiated the call
             from_agent: Agent that initiated the call
@@ -1003,8 +877,8 @@ class AnthropicCompletion(BaseLLM):
 
     def _handle_tool_use_conversation(
         self,
-        initial_response: Message | BetaMessage,
-        tool_uses: list[ToolUseBlock | BetaToolUseBlock],
+        initial_response: Message,
+        tool_uses: list[ToolUseBlock],
         params: dict[str, Any],
         available_functions: dict[str, Any],
         from_task: Any | None = None,
@@ -1121,40 +995,22 @@ class AnthropicCompletion(BaseLLM):
         response_model: type[BaseModel] | None = None,
     ) -> str | Any:
         """Handle non-streaming async message completion."""
+        if response_model:
+            structured_tool = {
+                "name": "structured_output",
+                "description": "Returns structured data according to the schema",
+                "input_schema": response_model.model_json_schema(),
+            }
+
+            params["tools"] = [structured_tool]
+            params["tool_choice"] = {"type": "tool", "name": "structured_output"}
+
         uses_file_api = _contains_file_id_reference(params.get("messages", []))
-        betas: list[str] = []
-        use_native_structured_output = False
-
-        if uses_file_api:
-            betas.append(ANTHROPIC_FILES_API_BETA)
-
-        extra_body: dict[str, Any] | None = None
-        if _is_pydantic_model_class(response_model):
-            schema = transform_schema(response_model.model_json_schema())
-            if _supports_native_structured_outputs(self.model):
-                use_native_structured_output = True
-                betas.append(ANTHROPIC_STRUCTURED_OUTPUTS_BETA)
-                extra_body = {
-                    "output_format": {
-                        "type": "json_schema",
-                        "schema": schema,
-                    }
-                }
-            else:
-                structured_tool = {
-                    "name": "structured_output",
-                    "description": "Output the structured response",
-                    "input_schema": schema,
-                }
-                params["tools"] = [structured_tool]
-                params["tool_choice"] = {"type": "tool", "name": "structured_output"}
 
         try:
-            if betas:
-                params["betas"] = betas
-                response = await self.async_client.beta.messages.create(
-                    **params, extra_body=extra_body
-                )
+            if uses_file_api:
+                params["betas"] = [ANTHROPIC_FILES_API_BETA]
+                response = await self.async_client.beta.messages.create(**params)
             else:
                 response = await self.async_client.messages.create(**params)
 
@@ -1167,41 +1023,27 @@ class AnthropicCompletion(BaseLLM):
         usage = self._extract_anthropic_token_usage(response)
         self._track_token_usage_internal(usage)
 
-        if _is_pydantic_model_class(response_model) and response.content:
-            if use_native_structured_output:
-                for block in response.content:
-                    if isinstance(block, (TextBlock, BetaTextBlock)):
-                        structured_data = response_model.model_validate_json(block.text)
-                        self._emit_call_completed_event(
-                            response=structured_data.model_dump_json(),
-                            call_type=LLMCallType.LLM_CALL,
-                            from_task=from_task,
-                            from_agent=from_agent,
-                            messages=params["messages"],
-                        )
-                        return structured_data
-            else:
-                for block in response.content:
-                    if (
-                        isinstance(block, ToolUseBlock)
-                        and block.name == "structured_output"
-                    ):
-                        structured_data = response_model.model_validate(block.input)
-                        self._emit_call_completed_event(
-                            response=structured_data.model_dump_json(),
-                            call_type=LLMCallType.LLM_CALL,
-                            from_task=from_task,
-                            from_agent=from_agent,
-                            messages=params["messages"],
-                        )
-                        return structured_data
+        if response_model and response.content:
+            tool_uses = [
+                block for block in response.content if isinstance(block, ToolUseBlock)
+            ]
+            if tool_uses and tool_uses[0].name == "structured_output":
+                structured_data = tool_uses[0].input
+                structured_json = json.dumps(structured_data)
+
+                self._emit_call_completed_event(
+                    response=structured_json,
+                    call_type=LLMCallType.LLM_CALL,
+                    from_task=from_task,
+                    from_agent=from_agent,
+                    messages=params["messages"],
+                )
+
+                return structured_json
 
-        # Handle both ToolUseBlock (regular API) and BetaToolUseBlock (beta API features)
         if response.content:
             tool_uses = [
-                block
-                for block in response.content
-                if isinstance(block, (ToolUseBlock, BetaToolUseBlock))
+                block for block in response.content if isinstance(block, ToolUseBlock)
             ]
 
             if tool_uses:
@@ -1253,54 +1095,26 @@ class AnthropicCompletion(BaseLLM):
         from_task: Any | None = None,
         from_agent: Any | None = None,
         response_model: type[BaseModel] | None = None,
-    ) -> str | Any:
+    ) -> str:
         """Handle async streaming message completion."""
-        betas: list[str] = []
-        use_native_structured_output = False
+        if response_model:
+            structured_tool = {
+                "name": "structured_output",
+                "description": "Returns structured data according to the schema",
+                "input_schema": response_model.model_json_schema(),
+            }
 
-        extra_body: dict[str, Any] | None = None
-        if _is_pydantic_model_class(response_model):
-            schema = transform_schema(response_model.model_json_schema())
-            if _supports_native_structured_outputs(self.model):
-                use_native_structured_output = True
-                betas.append(ANTHROPIC_STRUCTURED_OUTPUTS_BETA)
-                extra_body = {
-                    "output_format": {
-                        "type": "json_schema",
-                        "schema": schema,
-                    }
-                }
-            else:
-                structured_tool = {
-                    "name": "structured_output",
-                    "description": "Output the structured response",
-                    "input_schema": schema,
-                }
-                params["tools"] = [structured_tool]
-                params["tool_choice"] = {"type": "tool", "name": "structured_output"}
+            params["tools"] = [structured_tool]
+            params["tool_choice"] = {"type": "tool", "name": "structured_output"}
 
         full_response = ""
 
         stream_params = {k: v for k, v in params.items() if k != "stream"}
 
-        if betas:
-            stream_params["betas"] = betas
-
         current_tool_calls: dict[int, dict[str, Any]] = {}
 
-        stream_context = (
-            self.async_client.beta.messages.stream(
-                **stream_params, extra_body=extra_body
-            )
-            if betas
-            else self.async_client.messages.stream(**stream_params)
-        )
-        async with stream_context as stream:
-            response_id = None
+        async with self.async_client.messages.stream(**stream_params) as stream:
             async for event in stream:
-                if hasattr(event, "message") and hasattr(event.message, "id"):
-                    response_id = event.message.id
-
                 if hasattr(event, "delta") and hasattr(event.delta, "text"):
                     text_delta = event.delta.text
                     full_response += text_delta
@@ -1308,7 +1122,6 @@ class AnthropicCompletion(BaseLLM):
                         chunk=text_delta,
                         from_task=from_task,
                         from_agent=from_agent,
-                        response_id=response_id,
                     )
 
                 if event.type == "content_block_start":
@@ -1335,7 +1148,6 @@ class AnthropicCompletion(BaseLLM):
                                 "index": block_index,
                             },
                             call_type=LLMCallType.TOOL_CALL,
-                            response_id=response_id,
                         )
                 elif event.type == "content_block_delta":
                     if event.delta.type == "input_json_delta":
@@ -1359,48 +1171,42 @@ class AnthropicCompletion(BaseLLM):
                                     "index": block_index,
                                 },
                                 call_type=LLMCallType.TOOL_CALL,
-                                response_id=response_id,
                             )
 
-            final_message = await stream.get_final_message()
+            final_message: Message = await stream.get_final_message()
 
         usage = self._extract_anthropic_token_usage(final_message)
         self._track_token_usage_internal(usage)
 
-        if _is_pydantic_model_class(response_model):
-            if use_native_structured_output:
-                structured_data = response_model.model_validate_json(full_response)
+        if response_model and final_message.content:
+            tool_uses = [
+                block
+                for block in final_message.content
+                if isinstance(block, ToolUseBlock)
+            ]
+            if tool_uses and tool_uses[0].name == "structured_output":
+                structured_data = tool_uses[0].input
+                structured_json = json.dumps(structured_data)
+
                 self._emit_call_completed_event(
-                    response=structured_data.model_dump_json(),
+                    response=structured_json,
                     call_type=LLMCallType.LLM_CALL,
                     from_task=from_task,
                     from_agent=from_agent,
                     messages=params["messages"],
                 )
-                return structured_data
-            for block in final_message.content:
-                if (
-                    isinstance(block, ToolUseBlock)
-                    and block.name == "structured_output"
-                ):
-                    structured_data = response_model.model_validate(block.input)
-                    self._emit_call_completed_event(
-                        response=structured_data.model_dump_json(),
-                        call_type=LLMCallType.LLM_CALL,
-                        from_task=from_task,
-                        from_agent=from_agent,
-                        messages=params["messages"],
-                    )
-                    return structured_data
+
+                return structured_json
 
         if final_message.content:
             tool_uses = [
                 block
                 for block in final_message.content
-                if isinstance(block, (ToolUseBlock, BetaToolUseBlock))
+                if isinstance(block, ToolUseBlock)
             ]
 
             if tool_uses:
+                # If no available_functions, return tool calls for executor to handle
                 if not available_functions:
                     return list(tool_uses)
 
@@ -1427,8 +1233,8 @@ class AnthropicCompletion(BaseLLM):
 
     async def _ahandle_tool_use_conversation(
         self,
-        initial_response: Message | BetaMessage,
-        tool_uses: list[ToolUseBlock | BetaToolUseBlock],
+        initial_response: Message,
+        tool_uses: list[ToolUseBlock],
         params: dict[str, Any],
         available_functions: dict[str, Any],
         from_task: Any | None = None,
@@ -1536,9 +1342,7 @@ class AnthropicCompletion(BaseLLM):
         return int(200000 * CONTEXT_WINDOW_USAGE_RATIO)
 
     @staticmethod
-    def _extract_anthropic_token_usage(
-        response: Message | BetaMessage,
-    ) -> dict[str, Any]:
+    def _extract_anthropic_token_usage(response: Message) -> dict[str, Any]:
         """Extract token usage from Anthropic response."""
         if hasattr(response, "usage") and response.usage:
             usage = response.usage

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

@@ -92,7 +92,6 @@ class AzureCompletion(BaseLLM):
         stop: list[str] | None = None,
         stream: bool = False,
         interceptor: BaseInterceptor[Any, Any] | None = None,
-        response_format: type[BaseModel] | None = None,
         **kwargs: Any,
     ):
         """Initialize Azure AI Inference chat completion client.
@@ -112,9 +111,6 @@ class AzureCompletion(BaseLLM):
             stop: Stop sequences
             stream: Enable streaming responses
             interceptor: HTTP interceptor (not yet supported for Azure).
-            response_format: Pydantic model for structured output. Used as default when
-                           response_model is not passed to call()/acall() methods.
-                           Only works with OpenAI models deployed on Azure.
             **kwargs: Additional parameters
         """
         if interceptor is not None:
@@ -169,7 +165,6 @@ class AzureCompletion(BaseLLM):
         self.presence_penalty = presence_penalty
         self.max_tokens = max_tokens
         self.stream = stream
-        self.response_format = response_format
 
         self.is_openai_model = any(
             prefix in model.lower() for prefix in ["gpt-", "o1-", "text-"]
@@ -303,7 +298,6 @@ class AzureCompletion(BaseLLM):
                 from_task=from_task,
                 from_agent=from_agent,
             )
-            effective_response_model = response_model or self.response_format
 
             # Format messages for Azure
             formatted_messages = self._format_messages_for_azure(messages)
@@ -313,7 +307,7 @@ class AzureCompletion(BaseLLM):
 
             # Prepare completion parameters
             completion_params = self._prepare_completion_params(
-                formatted_messages, tools, effective_response_model
+                formatted_messages, tools, response_model
             )
 
             # Handle streaming vs non-streaming
@@ -323,7 +317,7 @@ class AzureCompletion(BaseLLM):
                     available_functions,
                     from_task,
                     from_agent,
-                    effective_response_model,
+                    response_model,
                 )
 
             return self._handle_completion(
@@ -331,7 +325,7 @@ class AzureCompletion(BaseLLM):
                 available_functions,
                 from_task,
                 from_agent,
-                effective_response_model,
+                response_model,
             )
 
         except Exception as e:
@@ -370,12 +364,11 @@ class AzureCompletion(BaseLLM):
                 from_task=from_task,
                 from_agent=from_agent,
             )
-            effective_response_model = response_model or self.response_format
 
             formatted_messages = self._format_messages_for_azure(messages)
 
             completion_params = self._prepare_completion_params(
-                formatted_messages, tools, effective_response_model
+                formatted_messages, tools, response_model
             )
 
             if self.stream:
@@ -384,7 +377,7 @@ class AzureCompletion(BaseLLM):
                     available_functions,
                     from_task,
                     from_agent,
-                    effective_response_model,
+                    response_model,
                 )
 
             return await self._ahandle_completion(
@@ -392,7 +385,7 @@ class AzureCompletion(BaseLLM):
                 available_functions,
                 from_task,
                 from_agent,
-                effective_response_model,
+                response_model,
             )
 
         except Exception as e:
@@ -557,7 +550,7 @@ class AzureCompletion(BaseLLM):
         params: AzureCompletionParams,
         from_task: Any | None = None,
         from_agent: Any | None = None,
-    ) -> BaseModel:
+    ) -> str:
         """Validate content against response model and emit completion event.
 
         Args:
@@ -568,23 +561,24 @@ class AzureCompletion(BaseLLM):
             from_agent: Agent that initiated the call
 
         Returns:
-            Validated Pydantic model instance
+            Validated and serialized JSON string
 
         Raises:
             ValueError: If validation fails
         """
         try:
             structured_data = response_model.model_validate_json(content)
+            structured_json = structured_data.model_dump_json()
 
             self._emit_call_completed_event(
-                response=structured_data.model_dump_json(),
+                response=structured_json,
                 call_type=LLMCallType.LLM_CALL,
                 from_task=from_task,
                 from_agent=from_agent,
                 messages=params["messages"],
             )
 
-            return structured_data
+            return structured_json
         except Exception as e:
             error_msg = f"Failed to validate structured output with model {response_model.__name__}: {e}"
             logging.error(error_msg)
@@ -622,6 +616,16 @@ class AzureCompletion(BaseLLM):
         usage = self._extract_azure_token_usage(response)
         self._track_token_usage_internal(usage)
 
+        if response_model and self.is_openai_model:
+            content = message.content or ""
+            return self._validate_and_emit_structured_output(
+                content=content,
+                response_model=response_model,
+                params=params,
+                from_task=from_task,
+                from_agent=from_agent,
+            )
+
         # If there are tool_calls but no available_functions, return the tool_calls
         # This allows the caller (e.g., executor) to handle tool execution
         if message.tool_calls and not available_functions:
@@ -661,15 +665,7 @@ class AzureCompletion(BaseLLM):
         # Extract content
         content = message.content or ""
 
-        if response_model and self.is_openai_model:
-            return self._validate_and_emit_structured_output(
-                content=content,
-                response_model=response_model,
-                params=params,
-                from_task=from_task,
-                from_agent=from_agent,
-            )
-
+        # Apply stop words
         content = self._apply_stop_words(content)
 
         # Emit completion event and return content
@@ -730,7 +726,6 @@ class AzureCompletion(BaseLLM):
         """
         if update.choices:
             choice = update.choices[0]
-            response_id = update.id if hasattr(update, "id") else None
             if choice.delta and choice.delta.content:
                 content_delta = choice.delta.content
                 full_response += content_delta
@@ -738,7 +733,6 @@ class AzureCompletion(BaseLLM):
                     chunk=content_delta,
                     from_task=from_task,
                     from_agent=from_agent,
-                    response_id=response_id,
                 )
 
             if choice.delta and choice.delta.tool_calls:
@@ -773,7 +767,6 @@ class AzureCompletion(BaseLLM):
                             "index": idx,
                         },
                         call_type=LLMCallType.TOOL_CALL,
-                        response_id=response_id,
                     )
 
         return full_response

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

@@ -16,7 +16,6 @@ from crewai.utilities.agent_utils import is_context_length_exceeded
 from crewai.utilities.exceptions.context_window_exceeding_exception import (
     LLMContextLengthExceededError,
 )
-from crewai.utilities.pydantic_schema_utils import generate_model_description
 from crewai.utilities.types import LLMMessage
 
 
@@ -45,78 +44,6 @@ except ImportError:
         'AWS Bedrock native provider not available, to install: uv add "crewai[bedrock]"'
     ) from None
 
-
-STRUCTURED_OUTPUT_TOOL_NAME = "structured_output"
-
-
-def _preprocess_structured_data(
-    data: dict[str, Any], response_model: type[BaseModel]
-) -> dict[str, Any]:
-    """Preprocess structured data to handle common LLM output format issues.
-
-    Some models (especially Claude on Bedrock) may return array fields as
-    markdown-formatted strings instead of proper JSON arrays. This function
-    attempts to convert such strings to arrays before validation.
-
-    Args:
-        data: The raw structured data from the tool response
-        response_model: The Pydantic model class to validate against
-
-    Returns:
-        Preprocessed data with string-to-array conversions where needed
-    """
-    import re
-    from typing import get_origin
-
-    # Get model field annotations
-    model_fields = response_model.model_fields
-
-    processed_data = dict(data)
-
-    for field_name, field_info in model_fields.items():
-        if field_name not in processed_data:
-            continue
-
-        value = processed_data[field_name]
-
-        # Check if the field expects a list type
-        annotation = field_info.annotation
-        origin = get_origin(annotation)
-
-        # Handle list[X] or List[X] types
-        is_list_type = origin is list or (
-            origin is not None and str(origin).startswith("list")
-        )
-
-        if is_list_type and isinstance(value, str):
-            # Try to parse markdown-style bullet points or numbered lists
-            lines = value.strip().split("\n")
-            parsed_items = []
-
-            for line in lines:
-                line = line.strip()
-                if not line:
-                    continue
-
-                # Remove common bullet point prefixes
-                # Matches: "- item", "* item", "• item", "1. item", "1) item"
-                cleaned = re.sub(r"^[-*•]\s*", "", line)
-                cleaned = re.sub(r"^\d+[.)]\s*", "", cleaned)
-                cleaned = cleaned.strip()
-
-                if cleaned:
-                    parsed_items.append(cleaned)
-
-            if parsed_items:
-                processed_data[field_name] = parsed_items
-                logging.debug(
-                    f"Converted markdown-formatted string to list for field '{field_name}': "
-                    f"{len(parsed_items)} items"
-                )
-
-    return processed_data
-
-
 try:
     from aiobotocore.session import (  # type: ignore[import-untyped]
         get_session as get_aiobotocore_session,
@@ -245,7 +172,6 @@ class BedrockCompletion(BaseLLM):
         additional_model_request_fields: dict[str, Any] | None = None,
         additional_model_response_field_paths: list[str] | None = None,
         interceptor: BaseInterceptor[Any, Any] | None = None,
-        response_format: type[BaseModel] | None = None,
         **kwargs: Any,
     ) -> None:
         """Initialize AWS Bedrock completion client.
@@ -266,8 +192,6 @@ class BedrockCompletion(BaseLLM):
             additional_model_request_fields: Model-specific request parameters
             additional_model_response_field_paths: Custom response field paths
             interceptor: HTTP interceptor (not yet supported for Bedrock).
-            response_format: Pydantic model for structured output. Used as default when
-                           response_model is not passed to call()/acall() methods.
             **kwargs: Additional parameters
         """
         if interceptor is not None:
@@ -323,8 +247,7 @@ class BedrockCompletion(BaseLLM):
         self.top_p = top_p
         self.top_k = top_k
         self.stream = stream
-        self.stop_sequences = stop_sequences
-        self.response_format = response_format
+        self.stop_sequences = stop_sequences or []
 
         # Store advanced features (optional)
         self.guardrail_config = guardrail_config
@@ -344,7 +267,7 @@ class BedrockCompletion(BaseLLM):
     @property
     def stop(self) -> list[str]:
         """Get stop sequences sent to the API."""
-        return [] if self.stop_sequences is None else list(self.stop_sequences)
+        return list(self.stop_sequences)
 
     @stop.setter
     def stop(self, value: Sequence[str] | str | None) -> None:
@@ -376,8 +299,6 @@ class BedrockCompletion(BaseLLM):
         response_model: type[BaseModel] | None = None,
     ) -> str | Any:
         """Call AWS Bedrock Converse API."""
-        effective_response_model = response_model or self.response_format
-
         try:
             # Emit call started event
             self._emit_call_started_event(
@@ -454,7 +375,6 @@ class BedrockCompletion(BaseLLM):
                     available_functions,
                     from_task,
                     from_agent,
-                    effective_response_model,
                 )
 
             return self._handle_converse(
@@ -463,7 +383,6 @@ class BedrockCompletion(BaseLLM):
                 available_functions,
                 from_task,
                 from_agent,
-                effective_response_model,
             )
 
         except Exception as e:
@@ -506,8 +425,6 @@ class BedrockCompletion(BaseLLM):
             NotImplementedError: If aiobotocore is not installed.
             LLMContextLengthExceededError: If context window is exceeded.
         """
-        effective_response_model = response_model or self.response_format
-
         if not AIOBOTOCORE_AVAILABLE:
             raise NotImplementedError(
                 "Async support for AWS Bedrock requires aiobotocore. "
@@ -577,21 +494,11 @@ class BedrockCompletion(BaseLLM):
 
             if self.stream:
                 return await self._ahandle_streaming_converse(
-                    formatted_messages,
-                    body,
-                    available_functions,
-                    from_task,
-                    from_agent,
-                    effective_response_model,
+                    formatted_messages, body, available_functions, from_task, from_agent
                 )
 
             return await self._ahandle_converse(
-                formatted_messages,
-                body,
-                available_functions,
-                from_task,
-                from_agent,
-                effective_response_model,
+                formatted_messages, body, available_functions, from_task, from_agent
             )
 
         except Exception as e:
@@ -613,62 +520,10 @@ class BedrockCompletion(BaseLLM):
         available_functions: Mapping[str, Any] | None = None,
         from_task: Any | None = None,
         from_agent: Any | None = None,
-        response_model: type[BaseModel] | None = None,
-    ) -> str | Any:
+    ) -> str:
         """Handle non-streaming converse API call following AWS best practices."""
-        if response_model:
-            # Check if structured_output tool already exists (from a previous recursive call)
-            existing_tool_config = body.get("toolConfig")
-            existing_tools: list[Any] = []
-            structured_output_already_exists = False
-
-            if existing_tool_config:
-                existing_tools = list(existing_tool_config.get("tools", []))
-                for tool in existing_tools:
-                    tool_spec = tool.get("toolSpec", {})
-                    if tool_spec.get("name") == STRUCTURED_OUTPUT_TOOL_NAME:
-                        structured_output_already_exists = True
-                        break
-
-            if not structured_output_already_exists:
-                structured_tool: ConverseToolTypeDef = {
-                    "toolSpec": {
-                        "name": STRUCTURED_OUTPUT_TOOL_NAME,
-                        "description": (
-                            "Use this tool to provide your final structured response. "
-                            "Call this tool when you have gathered all necessary information "
-                            "and are ready to provide the final answer in the required format."
-                        ),
-                        "inputSchema": {
-                            "json": generate_model_description(response_model)
-                            .get("json_schema", {})
-                            .get("schema", {})
-                        },
-                    }
-                }
-
-                if existing_tools:
-                    existing_tools.append(structured_tool)
-                    body["toolConfig"] = cast(
-                        "ToolConfigurationTypeDef",
-                        cast(object, {"tools": existing_tools}),
-                    )
-                else:
-                    # No existing tools, use only structured_output with forced toolChoice
-                    body["toolConfig"] = cast(
-                        "ToolConfigurationTypeDef",
-                        cast(
-                            object,
-                            {
-                                "tools": [structured_tool],
-                                "toolChoice": {
-                                    "tool": {"name": STRUCTURED_OUTPUT_TOOL_NAME}
-                                },
-                            },
-                        ),
-                    )
-
         try:
+            # Validate messages format before API call
             if not messages:
                 raise ValueError("Messages cannot be empty")
 
@@ -716,47 +571,15 @@ class BedrockCompletion(BaseLLM):
 
             # If there are tool uses but no available_functions, return them for the executor to handle
             tool_uses = [block["toolUse"] for block in content if "toolUse" in block]
-
-            # Check for structured_output tool call first
-            if response_model and tool_uses:
-                for tool_use in tool_uses:
-                    if tool_use.get("name") == STRUCTURED_OUTPUT_TOOL_NAME:
-                        structured_data = tool_use.get("input", {})
-                        structured_data = _preprocess_structured_data(
-                            structured_data, response_model
-                        )
-                        try:
-                            result = response_model.model_validate(structured_data)
-                            self._emit_call_completed_event(
-                                response=result.model_dump_json(),
-                                call_type=LLMCallType.LLM_CALL,
-                                from_task=from_task,
-                                from_agent=from_agent,
-                                messages=messages,
-                            )
-                            return result
-                        except Exception as e:
-                            error_msg = (
-                                f"Failed to validate {STRUCTURED_OUTPUT_TOOL_NAME} tool response "
-                                f"with model {response_model.__name__}: {e}"
-                            )
-                            logging.error(error_msg)
-                            raise ValueError(error_msg) from e
-
-            # Filter out structured_output from tool_uses returned to executor
-            non_structured_output_tool_uses = [
-                tu for tu in tool_uses if tu.get("name") != STRUCTURED_OUTPUT_TOOL_NAME
-            ]
-
-            if non_structured_output_tool_uses and not available_functions:
+            if tool_uses and not available_functions:
                 self._emit_call_completed_event(
-                    response=non_structured_output_tool_uses,
+                    response=tool_uses,
                     call_type=LLMCallType.TOOL_CALL,
                     from_task=from_task,
                     from_agent=from_agent,
                     messages=messages,
                 )
-                return non_structured_output_tool_uses
+                return tool_uses
 
             # Process content blocks and handle tool use correctly
             text_content = ""
@@ -773,9 +596,6 @@ class BedrockCompletion(BaseLLM):
                     function_name = tool_use_block["name"]
                     function_args = tool_use_block.get("input", {})
 
-                    if function_name == STRUCTURED_OUTPUT_TOOL_NAME:
-                        continue
-
                     logging.debug(
                         f"Tool use requested: {function_name} with ID {tool_use_id}"
                     )
@@ -812,12 +632,7 @@ class BedrockCompletion(BaseLLM):
                         )
 
                         return self._handle_converse(
-                            messages,
-                            body,
-                            available_functions,
-                            from_task,
-                            from_agent,
-                            response_model,
+                            messages, body, available_functions, from_task, from_agent
                         )
 
             # Apply stop sequences if configured
@@ -902,63 +717,8 @@ class BedrockCompletion(BaseLLM):
         available_functions: dict[str, Any] | None = None,
         from_task: Any | None = None,
         from_agent: Any | None = None,
-        response_model: type[BaseModel] | None = None,
     ) -> str:
         """Handle streaming converse API call with comprehensive event handling."""
-        if response_model:
-            # Check if structured_output tool already exists (from a previous recursive call)
-            existing_tool_config = body.get("toolConfig")
-            existing_tools: list[Any] = []
-            structured_output_already_exists = False
-
-            if existing_tool_config:
-                existing_tools = list(existing_tool_config.get("tools", []))
-                # Check if structured_output tool is already in the tools list
-                for tool in existing_tools:
-                    tool_spec = tool.get("toolSpec", {})
-                    if tool_spec.get("name") == STRUCTURED_OUTPUT_TOOL_NAME:
-                        structured_output_already_exists = True
-                        break
-
-            if not structured_output_already_exists:
-                structured_tool: ConverseToolTypeDef = {
-                    "toolSpec": {
-                        "name": STRUCTURED_OUTPUT_TOOL_NAME,
-                        "description": (
-                            "Use this tool to provide your final structured response. "
-                            "Call this tool when you have gathered all necessary information "
-                            "and are ready to provide the final answer in the required format."
-                        ),
-                        "inputSchema": {
-                            "json": generate_model_description(response_model)
-                            .get("json_schema", {})
-                            .get("schema", {})
-                        },
-                    }
-                }
-
-                if existing_tools:
-                    # Append structured_output to existing tools, don't force toolChoice
-                    existing_tools.append(structured_tool)
-                    body["toolConfig"] = cast(
-                        "ToolConfigurationTypeDef",
-                        cast(object, {"tools": existing_tools}),
-                    )
-                else:
-                    # No existing tools, use only structured_output with forced toolChoice
-                    body["toolConfig"] = cast(
-                        "ToolConfigurationTypeDef",
-                        cast(
-                            object,
-                            {
-                                "tools": [structured_tool],
-                                "toolChoice": {
-                                    "tool": {"name": STRUCTURED_OUTPUT_TOOL_NAME}
-                                },
-                            },
-                        ),
-                    )
-
         full_response = ""
         current_tool_use: dict[str, Any] | None = None
         tool_use_id: str | None = None
@@ -976,7 +736,6 @@ class BedrockCompletion(BaseLLM):
             )
 
             stream = response.get("stream")
-            response_id = None
             if stream:
                 for event in stream:
                     if "messageStart" in event:
@@ -1008,7 +767,6 @@ class BedrockCompletion(BaseLLM):
                                     "index": tool_use_index,
                                 },
                                 call_type=LLMCallType.TOOL_CALL,
-                                response_id=response_id,
                             )
                         logging.debug(
                             f"Tool use started in stream: {json.dumps(current_tool_use)} (ID: {tool_use_id})"
@@ -1024,7 +782,6 @@ class BedrockCompletion(BaseLLM):
                                 chunk=text_chunk,
                                 from_task=from_task,
                                 from_agent=from_agent,
-                                response_id=response_id,
                             )
                         elif "toolUse" in delta and current_tool_use:
                             tool_input = delta["toolUse"].get("input", "")
@@ -1045,83 +802,50 @@ class BedrockCompletion(BaseLLM):
                                         "index": tool_use_index,
                                     },
                                     call_type=LLMCallType.TOOL_CALL,
-                                    response_id=response_id,
                                 )
                     elif "contentBlockStop" in event:
                         logging.debug("Content block stopped in stream")
-                        if current_tool_use:
+                        if current_tool_use and available_functions:
                             function_name = current_tool_use["name"]
                             function_args = cast(
                                 dict[str, Any], current_tool_use.get("input", {})
                             )
-
-                            # Check if this is the structured_output tool
-                            if (
-                                function_name == STRUCTURED_OUTPUT_TOOL_NAME
-                                and response_model
-                            ):
-                                function_args = _preprocess_structured_data(
-                                    function_args, response_model
+                            tool_result = self._handle_tool_execution(
+                                function_name=function_name,
+                                function_args=function_args,
+                                available_functions=available_functions,
+                                from_task=from_task,
+                                from_agent=from_agent,
+                            )
+                            if tool_result is not None and tool_use_id:
+                                messages.append(
+                                    {
+                                        "role": "assistant",
+                                        "content": [{"toolUse": current_tool_use}],
+                                    }
                                 )
-                                try:
-                                    result = response_model.model_validate(
-                                        function_args
-                                    )
-                                    self._emit_call_completed_event(
-                                        response=result.model_dump_json(),
-                                        call_type=LLMCallType.LLM_CALL,
-                                        from_task=from_task,
-                                        from_agent=from_agent,
-                                        messages=messages,
-                                    )
-                                    return result  # type: ignore[return-value]
-                                except Exception as e:
-                                    error_msg = (
-                                        f"Failed to validate {STRUCTURED_OUTPUT_TOOL_NAME} tool response "
-                                        f"with model {response_model.__name__}: {e}"
-                                    )
-                                    logging.error(error_msg)
-                                    raise ValueError(error_msg) from e
-
-                            # Handle regular tool execution
-                            if available_functions:
-                                tool_result = self._handle_tool_execution(
-                                    function_name=function_name,
-                                    function_args=function_args,
-                                    available_functions=available_functions,
-                                    from_task=from_task,
-                                    from_agent=from_agent,
-                                )
-                                if tool_result is not None and tool_use_id:
-                                    messages.append(
-                                        {
-                                            "role": "assistant",
-                                            "content": [{"toolUse": current_tool_use}],
-                                        }
-                                    )
-                                    messages.append(
-                                        {
-                                            "role": "user",
-                                            "content": [
-                                                {
-                                                    "toolResult": {
-                                                        "toolUseId": tool_use_id,
-                                                        "content": [
-                                                            {"text": str(tool_result)}
-                                                        ],
-                                                    }
+                                messages.append(
+                                    {
+                                        "role": "user",
+                                        "content": [
+                                            {
+                                                "toolResult": {
+                                                    "toolUseId": tool_use_id,
+                                                    "content": [
+                                                        {"text": str(tool_result)}
+                                                    ],
                                                 }
-                                            ],
-                                        }
-                                    )
-                                    return self._handle_converse(
-                                        messages,
-                                        body,
-                                        available_functions,
-                                        from_task,
-                                        from_agent,
-                                        response_model,
-                                    )
+                                            }
+                                        ],
+                                    }
+                                )
+                                return self._handle_converse(
+                                    messages,
+                                    body,
+                                    available_functions,
+                                    from_task,
+                                    from_agent,
+                                )
                             current_tool_use = None
                             tool_use_id = None
                     elif "messageStop" in event:
@@ -1201,63 +925,8 @@ class BedrockCompletion(BaseLLM):
         available_functions: Mapping[str, Any] | None = None,
         from_task: Any | None = None,
         from_agent: Any | None = None,
-        response_model: type[BaseModel] | None = None,
-    ) -> str | Any:
+    ) -> str:
         """Handle async non-streaming converse API call."""
-        if response_model:
-            # Check if structured_output tool already exists (from a previous recursive call)
-            existing_tool_config = body.get("toolConfig")
-            existing_tools: list[Any] = []
-            structured_output_already_exists = False
-
-            if existing_tool_config:
-                existing_tools = list(existing_tool_config.get("tools", []))
-                # Check if structured_output tool is already in the tools list
-                for tool in existing_tools:
-                    tool_spec = tool.get("toolSpec", {})
-                    if tool_spec.get("name") == STRUCTURED_OUTPUT_TOOL_NAME:
-                        structured_output_already_exists = True
-                        break
-
-            if not structured_output_already_exists:
-                structured_tool: ConverseToolTypeDef = {
-                    "toolSpec": {
-                        "name": STRUCTURED_OUTPUT_TOOL_NAME,
-                        "description": (
-                            "Use this tool to provide your final structured response. "
-                            "Call this tool when you have gathered all necessary information "
-                            "and are ready to provide the final answer in the required format."
-                        ),
-                        "inputSchema": {
-                            "json": generate_model_description(response_model)
-                            .get("json_schema", {})
-                            .get("schema", {})
-                        },
-                    }
-                }
-
-                if existing_tools:
-                    # Append structured_output to existing tools, don't force toolChoice
-                    existing_tools.append(structured_tool)
-                    body["toolConfig"] = cast(
-                        "ToolConfigurationTypeDef",
-                        cast(object, {"tools": existing_tools}),
-                    )
-                else:
-                    # No existing tools, use only structured_output with forced toolChoice
-                    body["toolConfig"] = cast(
-                        "ToolConfigurationTypeDef",
-                        cast(
-                            object,
-                            {
-                                "tools": [structured_tool],
-                                "toolChoice": {
-                                    "tool": {"name": STRUCTURED_OUTPUT_TOOL_NAME}
-                                },
-                            },
-                        ),
-                    )
-
         try:
             if not messages:
                 raise ValueError("Messages cannot be empty")
@@ -1303,47 +972,15 @@ class BedrockCompletion(BaseLLM):
 
             # If there are tool uses but no available_functions, return them for the executor to handle
             tool_uses = [block["toolUse"] for block in content if "toolUse" in block]
-
-            # Check for structured_output tool call first
-            if response_model and tool_uses:
-                for tool_use in tool_uses:
-                    if tool_use.get("name") == STRUCTURED_OUTPUT_TOOL_NAME:
-                        structured_data = tool_use.get("input", {})
-                        structured_data = _preprocess_structured_data(
-                            structured_data, response_model
-                        )
-                        try:
-                            result = response_model.model_validate(structured_data)
-                            self._emit_call_completed_event(
-                                response=result.model_dump_json(),
-                                call_type=LLMCallType.LLM_CALL,
-                                from_task=from_task,
-                                from_agent=from_agent,
-                                messages=messages,
-                            )
-                            return result
-                        except Exception as e:
-                            error_msg = (
-                                f"Failed to validate {STRUCTURED_OUTPUT_TOOL_NAME} tool response "
-                                f"with model {response_model.__name__}: {e}"
-                            )
-                            logging.error(error_msg)
-                            raise ValueError(error_msg) from e
-
-            # Filter out structured_output from tool_uses returned to executor
-            non_structured_output_tool_uses = [
-                tu for tu in tool_uses if tu.get("name") != STRUCTURED_OUTPUT_TOOL_NAME
-            ]
-
-            if non_structured_output_tool_uses and not available_functions:
+            if tool_uses and not available_functions:
                 self._emit_call_completed_event(
-                    response=non_structured_output_tool_uses,
+                    response=tool_uses,
                     call_type=LLMCallType.TOOL_CALL,
                     from_task=from_task,
                     from_agent=from_agent,
                     messages=messages,
                 )
-                return non_structured_output_tool_uses
+                return tool_uses
 
             text_content = ""
 
@@ -1357,10 +994,6 @@ class BedrockCompletion(BaseLLM):
                     function_name = tool_use_block["name"]
                     function_args = tool_use_block.get("input", {})
 
-                    # Skip structured_output - it's handled above
-                    if function_name == STRUCTURED_OUTPUT_TOOL_NAME:
-                        continue
-
                     logging.debug(
                         f"Tool use requested: {function_name} with ID {tool_use_id}"
                     )
@@ -1396,12 +1029,7 @@ class BedrockCompletion(BaseLLM):
                         )
 
                         return await self._ahandle_converse(
-                            messages,
-                            body,
-                            available_functions,
-                            from_task,
-                            from_agent,
-                            response_model,
+                            messages, body, available_functions, from_task, from_agent
                         )
 
             text_content = self._apply_stop_words(text_content)
@@ -1474,63 +1102,8 @@ class BedrockCompletion(BaseLLM):
         available_functions: dict[str, Any] | None = None,
         from_task: Any | None = None,
         from_agent: Any | None = None,
-        response_model: type[BaseModel] | None = None,
     ) -> str:
         """Handle async streaming converse API call."""
-        if response_model:
-            # Check if structured_output tool already exists (from a previous recursive call)
-            existing_tool_config = body.get("toolConfig")
-            existing_tools: list[Any] = []
-            structured_output_already_exists = False
-
-            if existing_tool_config:
-                existing_tools = list(existing_tool_config.get("tools", []))
-                # Check if structured_output tool is already in the tools list
-                for tool in existing_tools:
-                    tool_spec = tool.get("toolSpec", {})
-                    if tool_spec.get("name") == STRUCTURED_OUTPUT_TOOL_NAME:
-                        structured_output_already_exists = True
-                        break
-
-            if not structured_output_already_exists:
-                structured_tool: ConverseToolTypeDef = {
-                    "toolSpec": {
-                        "name": STRUCTURED_OUTPUT_TOOL_NAME,
-                        "description": (
-                            "Use this tool to provide your final structured response. "
-                            "Call this tool when you have gathered all necessary information "
-                            "and are ready to provide the final answer in the required format."
-                        ),
-                        "inputSchema": {
-                            "json": generate_model_description(response_model)
-                            .get("json_schema", {})
-                            .get("schema", {})
-                        },
-                    }
-                }
-
-                if existing_tools:
-                    # Append structured_output to existing tools, don't force toolChoice
-                    existing_tools.append(structured_tool)
-                    body["toolConfig"] = cast(
-                        "ToolConfigurationTypeDef",
-                        cast(object, {"tools": existing_tools}),
-                    )
-                else:
-                    # No existing tools, use only structured_output with forced toolChoice
-                    body["toolConfig"] = cast(
-                        "ToolConfigurationTypeDef",
-                        cast(
-                            object,
-                            {
-                                "tools": [structured_tool],
-                                "toolChoice": {
-                                    "tool": {"name": STRUCTURED_OUTPUT_TOOL_NAME}
-                                },
-                            },
-                        ),
-                    )
-
         full_response = ""
         current_tool_use: dict[str, Any] | None = None
         tool_use_id: str | None = None
@@ -1549,7 +1122,6 @@ class BedrockCompletion(BaseLLM):
             )
 
             stream = response.get("stream")
-            response_id = None
             if stream:
                 async for event in stream:
                     if "messageStart" in event:
@@ -1581,7 +1153,6 @@ class BedrockCompletion(BaseLLM):
                                     "index": tool_use_index,
                                 },
                                 call_type=LLMCallType.TOOL_CALL,
-                                response_id=response_id,
                             )
                             logging.debug(
                                 f"Tool use started in stream: {current_tool_use.get('name')} (ID: {tool_use_id})"
@@ -1597,7 +1168,6 @@ class BedrockCompletion(BaseLLM):
                                 chunk=text_chunk,
                                 from_task=from_task,
                                 from_agent=from_agent,
-                                response_id=response_id,
                             )
                         elif "toolUse" in delta and current_tool_use:
                             tool_input = delta["toolUse"].get("input", "")
@@ -1618,89 +1188,58 @@ class BedrockCompletion(BaseLLM):
                                         "index": tool_use_index,
                                     },
                                     call_type=LLMCallType.TOOL_CALL,
-                                    response_id=response_id,
                                 )
 
                     elif "contentBlockStop" in event:
                         logging.debug("Content block stopped in stream")
-                        if current_tool_use:
+                        if current_tool_use and available_functions:
                             function_name = current_tool_use["name"]
                             function_args = cast(
                                 dict[str, Any], current_tool_use.get("input", {})
                             )
 
-                            # Check if this is the structured_output tool
-                            if (
-                                function_name == STRUCTURED_OUTPUT_TOOL_NAME
-                                and response_model
-                            ):
-                                function_args = _preprocess_structured_data(
-                                    function_args, response_model
-                                )
-                                try:
-                                    result = response_model.model_validate(
-                                        function_args
-                                    )
-                                    self._emit_call_completed_event(
-                                        response=result.model_dump_json(),
-                                        call_type=LLMCallType.LLM_CALL,
-                                        from_task=from_task,
-                                        from_agent=from_agent,
-                                        messages=messages,
-                                    )
-                                    return result  # type: ignore[return-value]
-                                except Exception as e:
-                                    error_msg = (
-                                        f"Failed to validate {STRUCTURED_OUTPUT_TOOL_NAME} tool response "
-                                        f"with model {response_model.__name__}: {e}"
-                                    )
-                                    logging.error(error_msg)
-                                    raise ValueError(error_msg) from e
+                            tool_result = self._handle_tool_execution(
+                                function_name=function_name,
+                                function_args=function_args,
+                                available_functions=available_functions,
+                                from_task=from_task,
+                                from_agent=from_agent,
+                            )
 
-                            # Handle regular tool execution
-                            if available_functions:
-                                tool_result = self._handle_tool_execution(
-                                    function_name=function_name,
-                                    function_args=function_args,
-                                    available_functions=available_functions,
-                                    from_task=from_task,
-                                    from_agent=from_agent,
+                            if tool_result is not None and tool_use_id:
+                                messages.append(
+                                    {
+                                        "role": "assistant",
+                                        "content": [{"toolUse": current_tool_use}],
+                                    }
                                 )
 
-                                if tool_result is not None and tool_use_id:
-                                    messages.append(
-                                        {
-                                            "role": "assistant",
-                                            "content": [{"toolUse": current_tool_use}],
-                                        }
-                                    )
-
-                                    messages.append(
-                                        {
-                                            "role": "user",
-                                            "content": [
-                                                {
-                                                    "toolResult": {
-                                                        "toolUseId": tool_use_id,
-                                                        "content": [
-                                                            {"text": str(tool_result)}
-                                                        ],
-                                                    }
+                                messages.append(
+                                    {
+                                        "role": "user",
+                                        "content": [
+                                            {
+                                                "toolResult": {
+                                                    "toolUseId": tool_use_id,
+                                                    "content": [
+                                                        {"text": str(tool_result)}
+                                                    ],
                                                 }
-                                            ],
-                                        }
-                                    )
+                                            }
+                                        ],
+                                    }
+                                )
 
-                                    return await self._ahandle_converse(
-                                        messages,
-                                        body,
-                                        available_functions,
-                                        from_task,
-                                        from_agent,
-                                        response_model,
-                                    )
-                            current_tool_use = None
-                            tool_use_id = None
+                                return await self._ahandle_converse(
+                                    messages,
+                                    body,
+                                    available_functions,
+                                    from_task,
+                                    from_agent,
+                                )
+
+                                current_tool_use = None
+                                tool_use_id = None
 
                     elif "messageStop" in event:
                         stop_reason = event["messageStop"].get("stopReason")

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

@@ -15,7 +15,6 @@ from crewai.utilities.agent_utils import is_context_length_exceeded
 from crewai.utilities.exceptions.context_window_exceeding_exception import (
     LLMContextLengthExceededError,
 )
-from crewai.utilities.pydantic_schema_utils import generate_model_description
 from crewai.utilities.types import LLMMessage
 
 
@@ -34,9 +33,6 @@ except ImportError:
     ) from None
 
 
-STRUCTURED_OUTPUT_TOOL_NAME = "structured_output"
-
-
 class GeminiCompletion(BaseLLM):
     """Google Gemini native completion implementation.
 
@@ -60,7 +56,6 @@ class GeminiCompletion(BaseLLM):
         client_params: dict[str, Any] | None = None,
         interceptor: BaseInterceptor[Any, Any] | None = None,
         use_vertexai: bool | None = None,
-        response_format: type[BaseModel] | None = None,
         **kwargs: Any,
     ):
         """Initialize Google Gemini chat completion client.
@@ -91,8 +86,6 @@ class GeminiCompletion(BaseLLM):
                          - None (default): Check GOOGLE_GENAI_USE_VERTEXAI env var
                          When using Vertex AI with API key (Express mode), http_options with
                          api_version="v1" is automatically configured.
-            response_format: Pydantic model for structured output. Used as default when
-                           response_model is not passed to call()/acall() methods.
             **kwargs: Additional parameters
         """
         if interceptor is not None:
@@ -128,16 +121,12 @@ class GeminiCompletion(BaseLLM):
         self.safety_settings = safety_settings or {}
         self.stop_sequences = stop_sequences or []
         self.tools: list[dict[str, Any]] | None = None
-        self.response_format = response_format
 
         # Model-specific settings
         version_match = re.search(r"gemini-(\d+(?:\.\d+)?)", model.lower())
         self.supports_tools = bool(
             version_match and float(version_match.group(1)) >= 1.5
         )
-        self.is_gemini_2_0 = bool(
-            version_match and float(version_match.group(1)) >= 2.0
-        )
 
     @property
     def stop(self) -> list[str]:
@@ -303,7 +292,6 @@ class GeminiCompletion(BaseLLM):
                 from_agent=from_agent,
             )
             self.tools = tools
-            effective_response_model = response_model or self.response_format
 
             formatted_content, system_instruction = self._format_messages_for_gemini(
                 messages
@@ -315,7 +303,7 @@ class GeminiCompletion(BaseLLM):
                 raise ValueError("LLM call blocked by before_llm_call hook")
 
             config = self._prepare_generation_config(
-                system_instruction, tools, effective_response_model
+                system_instruction, tools, response_model
             )
 
             if self.stream:
@@ -325,7 +313,7 @@ class GeminiCompletion(BaseLLM):
                     available_functions,
                     from_task,
                     from_agent,
-                    effective_response_model,
+                    response_model,
                 )
 
             return self._handle_completion(
@@ -334,7 +322,7 @@ class GeminiCompletion(BaseLLM):
                 available_functions,
                 from_task,
                 from_agent,
-                effective_response_model,
+                response_model,
             )
 
         except APIError as e:
@@ -386,14 +374,13 @@ class GeminiCompletion(BaseLLM):
                 from_agent=from_agent,
             )
             self.tools = tools
-            effective_response_model = response_model or self.response_format
 
             formatted_content, system_instruction = self._format_messages_for_gemini(
                 messages
             )
 
             config = self._prepare_generation_config(
-                system_instruction, tools, effective_response_model
+                system_instruction, tools, response_model
             )
 
             if self.stream:
@@ -403,7 +390,7 @@ class GeminiCompletion(BaseLLM):
                     available_functions,
                     from_task,
                     from_agent,
-                    effective_response_model,
+                    response_model,
                 )
 
             return await self._ahandle_completion(
@@ -412,7 +399,7 @@ class GeminiCompletion(BaseLLM):
                 available_functions,
                 from_task,
                 from_agent,
-                effective_response_model,
+                response_model,
             )
 
         except APIError as e:
@@ -445,14 +432,6 @@ class GeminiCompletion(BaseLLM):
 
         Returns:
             GenerateContentConfig object for Gemini API
-
-        Note:
-            Structured output support varies by model version:
-            - Gemini 1.5 and earlier: Uses response_schema (Pydantic model)
-            - Gemini 2.0+: Uses response_json_schema (JSON Schema) with propertyOrdering
-
-            When both tools AND response_model are present, we add a structured_output
-            pseudo-tool since Gemini doesn't support tools + response_schema together.
         """
         self.tools = tools
         config_params: dict[str, Any] = {}
@@ -477,41 +456,13 @@ class GeminiCompletion(BaseLLM):
         if self.stop_sequences:
             config_params["stop_sequences"] = self.stop_sequences
 
-        if tools and self.supports_tools:
-            gemini_tools = self._convert_tools_for_interference(tools)
-
-            if response_model:
-                schema_output = generate_model_description(response_model)
-                schema = schema_output.get("json_schema", {}).get("schema", {})
-                if self.is_gemini_2_0:
-                    schema = self._add_property_ordering(schema)
-
-                structured_output_tool = types.Tool(
-                    function_declarations=[
-                        types.FunctionDeclaration(
-                            name=STRUCTURED_OUTPUT_TOOL_NAME,
-                            description=(
-                                "Use this tool to provide your final structured response. "
-                                "Call this tool when you have gathered all necessary information "
-                                "and are ready to provide the final answer in the required format."
-                            ),
-                            parameters_json_schema=schema,
-                        )
-                    ]
-                )
-                gemini_tools.append(structured_output_tool)
-
-            config_params["tools"] = gemini_tools
-        elif response_model:
+        if response_model:
             config_params["response_mime_type"] = "application/json"
-            schema_output = generate_model_description(response_model)
-            schema = schema_output.get("json_schema", {}).get("schema", {})
+            config_params["response_schema"] = response_model.model_json_schema()
 
-            if self.is_gemini_2_0:
-                schema = self._add_property_ordering(schema)
-                config_params["response_json_schema"] = schema
-            else:
-                config_params["response_schema"] = response_model
+        # Handle tools for supported models
+        if tools and self.supports_tools:
+            config_params["tools"] = self._convert_tools_for_interference(tools)
 
         if self.safety_settings:
             config_params["safety_settings"] = self.safety_settings
@@ -532,7 +483,7 @@ class GeminiCompletion(BaseLLM):
             function_declaration = types.FunctionDeclaration(
                 name=name,
                 description=description,
-                parameters_json_schema=parameters if parameters else None,
+                parameters=parameters if parameters else None,
             )
 
             gemini_tool = types.Tool(function_declarations=[function_declaration])
@@ -586,10 +537,11 @@ class GeminiCompletion(BaseLLM):
             else:
                 parts.append(types.Part.from_text(text=str(content) if content else ""))
 
-            text_content: str = " ".join(p.text for p in parts if p.text is not None)
-
             if role == "system":
                 # Extract system instruction - Gemini handles it separately
+                text_content = " ".join(
+                    p.text for p in parts if hasattr(p, "text") and p.text
+                )
                 if system_instruction:
                     system_instruction += f"\n\n{text_content}"
                 else:
@@ -603,11 +555,7 @@ class GeminiCompletion(BaseLLM):
 
                 response_data: dict[str, Any]
                 try:
-                    parsed = json.loads(text_content) if text_content else {}
-                    if isinstance(parsed, dict):
-                        response_data = parsed
-                    else:
-                        response_data = {"result": parsed}
+                    response_data = json.loads(text_content) if text_content else {}
                 except (json.JSONDecodeError, TypeError):
                     response_data = {"result": text_content}
 
@@ -618,42 +566,33 @@ class GeminiCompletion(BaseLLM):
                     types.Content(role="user", parts=[function_response_part])
                 )
             elif role == "assistant" and message.get("tool_calls"):
-                raw_parts: list[Any] | None = message.get("raw_tool_call_parts")
-                if raw_parts and all(isinstance(p, types.Part) for p in raw_parts):
-                    tool_parts: list[types.Part] = list(raw_parts)
-                    if text_content:
-                        tool_parts.insert(0, types.Part.from_text(text=text_content))
-                else:
-                    tool_parts = []
-                    if text_content:
-                        tool_parts.append(types.Part.from_text(text=text_content))
+                parts: list[types.Part] = []
 
-                    tool_calls: list[dict[str, Any]] = message.get("tool_calls") or []
-                    for tool_call in tool_calls:
-                        func: dict[str, Any] = tool_call.get("function") or {}
-                        func_name: str = str(func.get("name") or "")
-                        func_args_raw: str | dict[str, Any] = (
-                            func.get("arguments") or {}
-                        )
+                if text_content:
+                    parts.append(types.Part.from_text(text=text_content))
 
-                        func_args: dict[str, Any]
-                        if isinstance(func_args_raw, str):
-                            try:
-                                func_args = (
-                                    json.loads(func_args_raw) if func_args_raw else {}
-                                )
-                            except (json.JSONDecodeError, TypeError):
-                                func_args = {}
-                        else:
-                            func_args = func_args_raw
+                tool_calls: list[dict[str, Any]] = message.get("tool_calls") or []
+                for tool_call in tool_calls:
+                    func: dict[str, Any] = tool_call.get("function") or {}
+                    func_name: str = str(func.get("name") or "")
+                    func_args_raw: str | dict[str, Any] = func.get("arguments") or {}
 
-                        tool_parts.append(
-                            types.Part.from_function_call(
-                                name=func_name, args=func_args
+                    func_args: dict[str, Any]
+                    if isinstance(func_args_raw, str):
+                        try:
+                            func_args = (
+                                json.loads(func_args_raw) if func_args_raw else {}
                             )
-                        )
+                        except (json.JSONDecodeError, TypeError):
+                            func_args = {}
+                    else:
+                        func_args = func_args_raw
 
-                contents.append(types.Content(role="model", parts=tool_parts))
+                    parts.append(
+                        types.Part.from_function_call(name=func_name, args=func_args)
+                    )
+
+                contents.append(types.Content(role="model", parts=parts))
             else:
                 # Convert role for Gemini (assistant -> model)
                 gemini_role = "model" if role == "assistant" else "user"
@@ -671,7 +610,7 @@ class GeminiCompletion(BaseLLM):
         messages_for_event: list[LLMMessage],
         from_task: Any | None = None,
         from_agent: Any | None = None,
-    ) -> BaseModel:
+    ) -> str:
         """Validate content against response model and emit completion event.
 
         Args:
@@ -682,23 +621,24 @@ class GeminiCompletion(BaseLLM):
             from_agent: Agent that initiated the call
 
         Returns:
-            Validated Pydantic model instance
+            Validated and serialized JSON string
 
         Raises:
             ValueError: If validation fails
         """
         try:
             structured_data = response_model.model_validate_json(content)
+            structured_json = structured_data.model_dump_json()
 
             self._emit_call_completed_event(
-                response=structured_data.model_dump_json(),
+                response=structured_json,
                 call_type=LLMCallType.LLM_CALL,
                 from_task=from_task,
                 from_agent=from_agent,
                 messages=messages_for_event,
             )
 
-            return structured_data
+            return structured_json
         except Exception as e:
             error_msg = f"Failed to validate structured output with model {response_model.__name__}: {e}"
             logging.error(error_msg)
@@ -711,7 +651,7 @@ class GeminiCompletion(BaseLLM):
         response_model: type[BaseModel] | None = None,
         from_task: Any | None = None,
         from_agent: Any | None = None,
-    ) -> str | BaseModel:
+    ) -> str:
         """Finalize completion response with validation and event emission.
 
         Args:
@@ -722,7 +662,7 @@ class GeminiCompletion(BaseLLM):
             from_agent: Agent that initiated the call
 
         Returns:
-            Final response content after processing (str or Pydantic model if response_model provided)
+            Final response content after processing
         """
         messages_for_event = self._convert_contents_to_dict(contents)
 
@@ -748,47 +688,6 @@ class GeminiCompletion(BaseLLM):
             messages_for_event, content, from_agent
         )
 
-    def _handle_structured_output_tool_call(
-        self,
-        structured_data: dict[str, Any],
-        response_model: type[BaseModel],
-        contents: list[types.Content],
-        from_task: Any | None = None,
-        from_agent: Any | None = None,
-    ) -> BaseModel:
-        """Validate and emit event for structured_output tool call.
-
-        Args:
-            structured_data: The arguments passed to the structured_output tool
-            response_model: Pydantic model to validate against
-            contents: Original contents for event conversion
-            from_task: Task that initiated the call
-            from_agent: Agent that initiated the call
-
-        Returns:
-            Validated Pydantic model instance
-
-        Raises:
-            ValueError: If validation fails
-        """
-        try:
-            validated_data = response_model.model_validate(structured_data)
-            self._emit_call_completed_event(
-                response=validated_data.model_dump_json(),
-                call_type=LLMCallType.LLM_CALL,
-                from_task=from_task,
-                from_agent=from_agent,
-                messages=self._convert_contents_to_dict(contents),
-            )
-            return validated_data
-        except Exception as e:
-            error_msg = (
-                f"Failed to validate {STRUCTURED_OUTPUT_TOOL_NAME} tool response "
-                f"with model {response_model.__name__}: {e}"
-            )
-            logging.error(error_msg)
-            raise ValueError(error_msg) from e
-
     def _process_response_with_tools(
         self,
         response: GenerateContentResponse,
@@ -819,47 +718,17 @@ class GeminiCompletion(BaseLLM):
                     part for part in candidate.content.parts if part.function_call
                 ]
 
-                # Check for structured_output pseudo-tool call (used when tools + response_model)
-                if response_model and function_call_parts:
-                    for part in function_call_parts:
-                        if (
-                            part.function_call
-                            and part.function_call.name == STRUCTURED_OUTPUT_TOOL_NAME
-                        ):
-                            structured_data = (
-                                dict(part.function_call.args)
-                                if part.function_call.args
-                                else {}
-                            )
-                            return self._handle_structured_output_tool_call(
-                                structured_data=structured_data,
-                                response_model=response_model,
-                                contents=contents,
-                                from_task=from_task,
-                                from_agent=from_agent,
-                            )
-
-                # Filter out structured_output from function calls returned to executor
-                non_structured_output_parts = [
-                    part
-                    for part in function_call_parts
-                    if not (
-                        part.function_call
-                        and part.function_call.name == STRUCTURED_OUTPUT_TOOL_NAME
-                    )
-                ]
-
                 # If there are function calls but no available_functions,
                 # return them for the executor to handle (like OpenAI/Anthropic)
-                if non_structured_output_parts and not available_functions:
+                if function_call_parts and not available_functions:
                     self._emit_call_completed_event(
-                        response=non_structured_output_parts,
+                        response=function_call_parts,
                         call_type=LLMCallType.TOOL_CALL,
                         from_task=from_task,
                         from_agent=from_agent,
                         messages=self._convert_contents_to_dict(contents),
                     )
-                    return non_structured_output_parts
+                    return function_call_parts
 
                 # Otherwise execute the tools internally
                 for part in candidate.content.parts:
@@ -867,9 +736,6 @@ class GeminiCompletion(BaseLLM):
                         function_name = part.function_call.name
                         if function_name is None:
                             continue
-                        # Skip structured_output - it's handled above
-                        if function_name == STRUCTURED_OUTPUT_TOOL_NAME:
-                            continue
                         function_args = (
                             dict(part.function_call.args)
                             if part.function_call.args
@@ -888,15 +754,12 @@ class GeminiCompletion(BaseLLM):
                             return result
 
         content = self._extract_text_from_response(response)
-
-        effective_response_model = None if self.tools else response_model
-        if not effective_response_model:
-            content = self._apply_stop_words(content)
+        content = self._apply_stop_words(content)
 
         return self._finalize_completion_response(
             content=content,
             contents=contents,
-            response_model=effective_response_model,
+            response_model=response_model,
             from_task=from_task,
             from_agent=from_agent,
         )
@@ -923,7 +786,6 @@ class GeminiCompletion(BaseLLM):
         Returns:
             Tuple of (updated full_response, updated function_calls, updated usage_data)
         """
-        response_id = chunk.response_id if hasattr(chunk, "response_id") else None
         if chunk.usage_metadata:
             usage_data = self._extract_token_usage(chunk)
 
@@ -933,7 +795,6 @@ class GeminiCompletion(BaseLLM):
                 chunk=chunk.text,
                 from_task=from_task,
                 from_agent=from_agent,
-                response_id=response_id,
             )
 
         if chunk.candidates:
@@ -970,7 +831,6 @@ class GeminiCompletion(BaseLLM):
                                 "index": call_index,
                             },
                             call_type=LLMCallType.TOOL_CALL,
-                            response_id=response_id,
                         )
 
         return full_response, function_calls, usage_data
@@ -985,7 +845,7 @@ class GeminiCompletion(BaseLLM):
         from_task: Any | None = None,
         from_agent: Any | None = None,
         response_model: type[BaseModel] | None = None,
-    ) -> str | BaseModel | list[dict[str, Any]]:
+    ) -> str | list[dict[str, Any]]:
         """Finalize streaming response with usage tracking, function execution, and events.
 
         Args:
@@ -1003,27 +863,9 @@ class GeminiCompletion(BaseLLM):
         """
         self._track_token_usage_internal(usage_data)
 
-        if response_model and function_calls:
-            for call_data in function_calls.values():
-                if call_data.get("name") == STRUCTURED_OUTPUT_TOOL_NAME:
-                    structured_data = call_data.get("args", {})
-                    return self._handle_structured_output_tool_call(
-                        structured_data=structured_data,
-                        response_model=response_model,
-                        contents=contents,
-                        from_task=from_task,
-                        from_agent=from_agent,
-                    )
-
-        non_structured_output_calls = {
-            idx: call_data
-            for idx, call_data in function_calls.items()
-            if call_data.get("name") != STRUCTURED_OUTPUT_TOOL_NAME
-        }
-
         # If there are function calls but no available_functions,
         # return them for the executor to handle
-        if non_structured_output_calls and not available_functions:
+        if function_calls and not available_functions:
             formatted_function_calls = [
                 {
                     "id": call_data["id"],
@@ -1033,7 +875,7 @@ class GeminiCompletion(BaseLLM):
                     },
                     "type": "function",
                 }
-                for call_data in non_structured_output_calls.values()
+                for call_data in function_calls.values()
             ]
             self._emit_call_completed_event(
                 response=formatted_function_calls,
@@ -1044,9 +886,9 @@ class GeminiCompletion(BaseLLM):
             )
             return formatted_function_calls
 
-        # Handle completed function calls (excluding structured_output)
-        if non_structured_output_calls and available_functions:
-            for call_data in non_structured_output_calls.values():
+        # Handle completed function calls
+        if function_calls and available_functions:
+            for call_data in function_calls.values():
                 function_name = call_data["name"]
                 function_args = call_data["args"]
 
@@ -1070,15 +912,10 @@ class GeminiCompletion(BaseLLM):
                 if result is not None:
                     return result
 
-        # When tools are present, structured output should come via the structured_output
-        # pseudo-tool, not via direct text response. If we reach here with tools present,
-        # the LLM chose to return plain text instead of calling structured_output.
-        effective_response_model = None if self.tools else response_model
-
         return self._finalize_completion_response(
             content=full_response,
             contents=contents,
-            response_model=effective_response_model,
+            response_model=response_model,
             from_task=from_task,
             from_agent=from_agent,
         )
@@ -1128,7 +965,7 @@ class GeminiCompletion(BaseLLM):
         from_task: Any | None = None,
         from_agent: Any | None = None,
         response_model: type[BaseModel] | None = None,
-    ) -> str | BaseModel | list[dict[str, Any]] | Any:
+    ) -> str:
         """Handle streaming content generation."""
         full_response = ""
         function_calls: dict[int, dict[str, Any]] = {}
@@ -1206,7 +1043,7 @@ class GeminiCompletion(BaseLLM):
         from_task: Any | None = None,
         from_agent: Any | None = None,
         response_model: type[BaseModel] | None = None,
-    ) -> str | Any:
+    ) -> str:
         """Handle async streaming content generation."""
         full_response = ""
         function_calls: dict[int, dict[str, Any]] = {}
@@ -1328,36 +1165,6 @@ class GeminiCompletion(BaseLLM):
 
         return "".join(text_parts)
 
-    @staticmethod
-    def _add_property_ordering(schema: dict[str, Any]) -> dict[str, Any]:
-        """Add propertyOrdering to JSON schema for Gemini 2.0 compatibility.
-
-        Gemini 2.0 models require an explicit propertyOrdering list to define
-        the preferred structure of JSON objects. This recursively adds
-        propertyOrdering to all objects in the schema.
-
-        Args:
-            schema: JSON schema dictionary.
-
-        Returns:
-            Modified schema with propertyOrdering added to all objects.
-        """
-        if isinstance(schema, dict):
-            if schema.get("type") == "object" and "properties" in schema:
-                properties = schema["properties"]
-                if properties and "propertyOrdering" not in schema:
-                    schema["propertyOrdering"] = list(properties.keys())
-
-            for value in schema.values():
-                if isinstance(value, dict):
-                    GeminiCompletion._add_property_ordering(value)
-                elif isinstance(value, list):
-                    for item in value:
-                        if isinstance(item, dict):
-                            GeminiCompletion._add_property_ordering(item)
-
-        return schema
-
     @staticmethod
     def _convert_contents_to_dict(
         contents: list[types.Content],

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

@@ -693,14 +693,14 @@ class OpenAICompletion(BaseLLM):
         if response_model or self.response_format:
             format_model = response_model or self.response_format
             if isinstance(format_model, type) and issubclass(format_model, BaseModel):
-                schema_output = generate_model_description(format_model)
-                json_schema = schema_output.get("json_schema", {})
+                schema = format_model.model_json_schema()
+                schema["additionalProperties"] = False
                 params["text"] = {
                     "format": {
                         "type": "json_schema",
-                        "name": json_schema.get("name", format_model.__name__),
-                        "strict": json_schema.get("strict", True),
-                        "schema": json_schema.get("schema", {}),
+                        "name": format_model.__name__,
+                        "strict": True,
+                        "schema": schema,
                     }
                 }
             elif isinstance(format_model, dict):
@@ -848,6 +848,7 @@ class OpenAICompletion(BaseLLM):
                         return result
 
             content = response.output_text or ""
+            content = self._apply_stop_words(content)
 
             if response_model:
                 try:
@@ -865,8 +866,6 @@ class OpenAICompletion(BaseLLM):
                 except ValueError as e:
                     logging.warning(f"Structured output validation failed: {e}")
 
-            content = self._apply_stop_words(content)
-
             self._emit_call_completed_event(
                 response=content,
                 call_type=LLMCallType.LLM_CALL,
@@ -980,6 +979,7 @@ class OpenAICompletion(BaseLLM):
                         return result
 
             content = response.output_text or ""
+            content = self._apply_stop_words(content)
 
             if response_model:
                 try:
@@ -997,8 +997,6 @@ class OpenAICompletion(BaseLLM):
                 except ValueError as e:
                     logging.warning(f"Structured output validation failed: {e}")
 
-            content = self._apply_stop_words(content)
-
             self._emit_call_completed_event(
                 response=content,
                 call_type=LLMCallType.LLM_CALL,
@@ -1049,12 +1047,8 @@ class OpenAICompletion(BaseLLM):
         final_response: Response | None = None
 
         stream = self.client.responses.create(**params)
-        response_id_stream = None
 
         for event in stream:
-            if event.type == "response.created":
-                response_id_stream = event.response.id
-
             if event.type == "response.output_text.delta":
                 delta_text = event.delta or ""
                 full_response += delta_text
@@ -1062,7 +1056,6 @@ class OpenAICompletion(BaseLLM):
                     chunk=delta_text,
                     from_task=from_task,
                     from_agent=from_agent,
-                    response_id=response_id_stream,
                 )
 
             elif event.type == "response.function_call_arguments.delta":
@@ -1133,6 +1126,8 @@ class OpenAICompletion(BaseLLM):
                 if result is not None:
                     return result
 
+        full_response = self._apply_stop_words(full_response)
+
         if response_model:
             try:
                 structured_result = self._validate_structured_output(
@@ -1149,8 +1144,6 @@ class OpenAICompletion(BaseLLM):
             except ValueError as e:
                 logging.warning(f"Structured output validation failed: {e}")
 
-        full_response = self._apply_stop_words(full_response)
-
         self._emit_call_completed_event(
             response=full_response,
             call_type=LLMCallType.LLM_CALL,
@@ -1177,12 +1170,8 @@ class OpenAICompletion(BaseLLM):
         final_response: Response | None = None
 
         stream = await self.async_client.responses.create(**params)
-        response_id_stream = None
 
         async for event in stream:
-            if event.type == "response.created":
-                response_id_stream = event.response.id
-
             if event.type == "response.output_text.delta":
                 delta_text = event.delta or ""
                 full_response += delta_text
@@ -1190,7 +1179,6 @@ class OpenAICompletion(BaseLLM):
                     chunk=delta_text,
                     from_task=from_task,
                     from_agent=from_agent,
-                    response_id=response_id_stream,
                 )
 
             elif event.type == "response.function_call_arguments.delta":
@@ -1261,6 +1249,8 @@ class OpenAICompletion(BaseLLM):
                 if result is not None:
                     return result
 
+        full_response = self._apply_stop_words(full_response)
+
         if response_model:
             try:
                 structured_result = self._validate_structured_output(
@@ -1277,8 +1267,6 @@ class OpenAICompletion(BaseLLM):
             except ValueError as e:
                 logging.warning(f"Structured output validation failed: {e}")
 
-        full_response = self._apply_stop_words(full_response)
-
         self._emit_call_completed_event(
             response=full_response,
             call_type=LLMCallType.LLM_CALL,
@@ -1532,7 +1520,6 @@ class OpenAICompletion(BaseLLM):
                 "function": {
                     "name": name,
                     "description": description,
-                    "strict": True,
                 },
             }
 
@@ -1573,14 +1560,15 @@ class OpenAICompletion(BaseLLM):
 
                 parsed_object = parsed_response.choices[0].message.parsed
                 if parsed_object:
+                    structured_json = parsed_object.model_dump_json()
                     self._emit_call_completed_event(
-                        response=parsed_object.model_dump_json(),
+                        response=structured_json,
                         call_type=LLMCallType.LLM_CALL,
                         from_task=from_task,
                         from_agent=from_agent,
                         messages=params["messages"],
                     )
-                    return parsed_object
+                    return structured_json
 
             response: ChatCompletion = self.client.chat.completions.create(**params)
 
@@ -1626,6 +1614,7 @@ class OpenAICompletion(BaseLLM):
                     return result
 
             content = message.content or ""
+            content = self._apply_stop_words(content)
 
             if self.response_format and isinstance(self.response_format, type):
                 try:
@@ -1643,8 +1632,6 @@ class OpenAICompletion(BaseLLM):
                 except ValueError as e:
                     logging.warning(f"Structured output validation failed: {e}")
 
-            content = self._apply_stop_words(content)
-
             self._emit_call_completed_event(
                 response=content,
                 call_type=LLMCallType.LLM_CALL,
@@ -1695,7 +1682,7 @@ class OpenAICompletion(BaseLLM):
         from_task: Any | None = None,
         from_agent: Any | None = None,
         response_model: type[BaseModel] | None = None,
-    ) -> str | BaseModel:
+    ) -> str:
         """Handle streaming chat completion."""
         full_response = ""
         tool_calls: dict[int, dict[str, Any]] = {}
@@ -1712,8 +1699,6 @@ class OpenAICompletion(BaseLLM):
                 **parse_params, response_format=response_model
             ) as stream:
                 for chunk in stream:
-                    response_id_stream = chunk.id if hasattr(chunk, "id") else None
-
                     if chunk.type == "content.delta":
                         delta_content = chunk.delta
                         if delta_content:
@@ -1721,7 +1706,6 @@ class OpenAICompletion(BaseLLM):
                                 chunk=delta_content,
                                 from_task=from_task,
                                 from_agent=from_agent,
-                                response_id=response_id_stream,
                             )
 
                 final_completion = stream.get_final_completion()
@@ -1731,14 +1715,15 @@ class OpenAICompletion(BaseLLM):
                     if final_completion.choices:
                         parsed_result = final_completion.choices[0].message.parsed
                         if parsed_result:
+                            structured_json = parsed_result.model_dump_json()
                             self._emit_call_completed_event(
-                                response=parsed_result.model_dump_json(),
+                                response=structured_json,
                                 call_type=LLMCallType.LLM_CALL,
                                 from_task=from_task,
                                 from_agent=from_agent,
                                 messages=params["messages"],
                             )
-                            return parsed_result
+                            return structured_json
 
             logging.error("Failed to get parsed result from stream")
             return ""
@@ -1750,10 +1735,6 @@ class OpenAICompletion(BaseLLM):
         usage_data = {"total_tokens": 0}
 
         for completion_chunk in completion_stream:
-            response_id_stream = (
-                completion_chunk.id if hasattr(completion_chunk, "id") else None
-            )
-
             if hasattr(completion_chunk, "usage") and completion_chunk.usage:
                 usage_data = self._extract_openai_token_usage(completion_chunk)
                 continue
@@ -1770,7 +1751,6 @@ class OpenAICompletion(BaseLLM):
                     chunk=chunk_delta.content,
                     from_task=from_task,
                     from_agent=from_agent,
-                    response_id=response_id_stream,
                 )
 
             if chunk_delta.tool_calls:
@@ -1809,7 +1789,6 @@ class OpenAICompletion(BaseLLM):
                             "index": tool_calls[tool_index]["index"],
                         },
                         call_type=LLMCallType.TOOL_CALL,
-                        response_id=response_id_stream,
                     )
 
         self._track_token_usage_internal(usage_data)
@@ -1889,14 +1868,15 @@ class OpenAICompletion(BaseLLM):
 
                 parsed_object = parsed_response.choices[0].message.parsed
                 if parsed_object:
+                    structured_json = parsed_object.model_dump_json()
                     self._emit_call_completed_event(
-                        response=parsed_object.model_dump_json(),
+                        response=structured_json,
                         call_type=LLMCallType.LLM_CALL,
                         from_task=from_task,
                         from_agent=from_agent,
                         messages=params["messages"],
                     )
-                    return parsed_object
+                    return structured_json
 
             response: ChatCompletion = await self.async_client.chat.completions.create(
                 **params
@@ -1944,6 +1924,7 @@ class OpenAICompletion(BaseLLM):
                     return result
 
             content = message.content or ""
+            content = self._apply_stop_words(content)
 
             if self.response_format and isinstance(self.response_format, type):
                 try:
@@ -1961,8 +1942,6 @@ class OpenAICompletion(BaseLLM):
                 except ValueError as e:
                     logging.warning(f"Structured output validation failed: {e}")
 
-            content = self._apply_stop_words(content)
-
             self._emit_call_completed_event(
                 response=content,
                 call_type=LLMCallType.LLM_CALL,
@@ -2008,7 +1987,7 @@ class OpenAICompletion(BaseLLM):
         from_task: Any | None = None,
         from_agent: Any | None = None,
         response_model: type[BaseModel] | None = None,
-    ) -> str | BaseModel:
+    ) -> str:
         """Handle async streaming chat completion."""
         full_response = ""
         tool_calls: dict[int, dict[str, Any]] = {}
@@ -2021,8 +2000,6 @@ class OpenAICompletion(BaseLLM):
             accumulated_content = ""
             usage_data = {"total_tokens": 0}
             async for chunk in completion_stream:
-                response_id_stream = chunk.id if hasattr(chunk, "id") else None
-
                 if hasattr(chunk, "usage") and chunk.usage:
                     usage_data = self._extract_openai_token_usage(chunk)
                     continue
@@ -2039,23 +2016,23 @@ class OpenAICompletion(BaseLLM):
                         chunk=delta.content,
                         from_task=from_task,
                         from_agent=from_agent,
-                        response_id=response_id_stream,
                     )
 
             self._track_token_usage_internal(usage_data)
 
             try:
                 parsed_object = response_model.model_validate_json(accumulated_content)
+                structured_json = parsed_object.model_dump_json()
 
                 self._emit_call_completed_event(
-                    response=parsed_object.model_dump_json(),
+                    response=structured_json,
                     call_type=LLMCallType.LLM_CALL,
                     from_task=from_task,
                     from_agent=from_agent,
                     messages=params["messages"],
                 )
 
-                return parsed_object
+                return structured_json
             except Exception as e:
                 logging.error(f"Failed to parse structured output from stream: {e}")
                 self._emit_call_completed_event(
@@ -2074,8 +2051,6 @@ class OpenAICompletion(BaseLLM):
         usage_data = {"total_tokens": 0}
 
         async for chunk in stream:
-            response_id_stream = chunk.id if hasattr(chunk, "id") else None
-
             if hasattr(chunk, "usage") and chunk.usage:
                 usage_data = self._extract_openai_token_usage(chunk)
                 continue
@@ -2092,7 +2067,6 @@ class OpenAICompletion(BaseLLM):
                     chunk=chunk_delta.content,
                     from_task=from_task,
                     from_agent=from_agent,
-                    response_id=response_id_stream,
                 )
 
             if chunk_delta.tool_calls:
@@ -2131,7 +2105,6 @@ class OpenAICompletion(BaseLLM):
                             "index": tool_calls[tool_index]["index"],
                         },
                         call_type=LLMCallType.TOOL_CALL,
-                        response_id=response_id_stream,
                     )
 
         self._track_token_usage_internal(usage_data)

lib/crewai/src/crewai/llms/providers/utils/common.py

@@ -2,7 +2,6 @@ import logging
 import re
 from typing import Any
 
-from crewai.utilities.pydantic_schema_utils import generate_model_description
 from crewai.utilities.string_utils import sanitize_tool_name
 
 
@@ -78,8 +77,7 @@ def extract_tool_info(tool: dict[str, Any]) -> tuple[str, str, dict[str, Any]]:
         # Also check for args_schema (Pydantic format)
         if not parameters and "args_schema" in tool:
             if hasattr(tool["args_schema"], "model_json_schema"):
-                schema_output = generate_model_description(tool["args_schema"])
-                parameters = schema_output.get("json_schema", {}).get("schema", {})
+                parameters = tool["args_schema"].model_json_schema()
 
     return name, description, parameters
 

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

@@ -12,17 +12,15 @@ from crewai.utilities.paths import db_storage_path
 class LTMSQLiteStorage:
     """SQLite storage class for long-term memory data."""
 
-    def __init__(self, db_path: str | None = None, verbose: bool = True) -> None:
+    def __init__(self, db_path: str | None = None) -> None:
         """Initialize the SQLite storage.
 
         Args:
             db_path: Optional path to the database file.
-            verbose: Whether to print error messages.
         """
         if db_path is None:
             db_path = str(Path(db_storage_path()) / "long_term_memory_storage.db")
         self.db_path = db_path
-        self._verbose = verbose
         self._printer: Printer = Printer()
         Path(self.db_path).parent.mkdir(parents=True, exist_ok=True)
         self._initialize_db()
@@ -46,11 +44,10 @@ class LTMSQLiteStorage:
 
                 conn.commit()
         except sqlite3.Error as e:
-            if self._verbose:
-                self._printer.print(
-                    content=f"MEMORY ERROR: An error occurred during database initialization: {e}",
-                    color="red",
-                )
+            self._printer.print(
+                content=f"MEMORY ERROR: An error occurred during database initialization: {e}",
+                color="red",
+            )
 
     def save(
         self,
@@ -72,11 +69,10 @@ class LTMSQLiteStorage:
                 )
                 conn.commit()
         except sqlite3.Error as e:
-            if self._verbose:
-                self._printer.print(
-                    content=f"MEMORY ERROR: An error occurred while saving to LTM: {e}",
-                    color="red",
-                )
+            self._printer.print(
+                content=f"MEMORY ERROR: An error occurred while saving to LTM: {e}",
+                color="red",
+            )
 
     def load(self, task_description: str, latest_n: int) -> list[dict[str, Any]] | None:
         """Queries the LTM table by task description with error handling."""
@@ -105,11 +101,10 @@ class LTMSQLiteStorage:
                     ]
 
         except sqlite3.Error as e:
-            if self._verbose:
-                self._printer.print(
-                    content=f"MEMORY ERROR: An error occurred while querying LTM: {e}",
-                    color="red",
-                )
+            self._printer.print(
+                content=f"MEMORY ERROR: An error occurred while querying LTM: {e}",
+                color="red",
+            )
         return None
 
     def reset(self) -> None:
@@ -121,11 +116,10 @@ class LTMSQLiteStorage:
                 conn.commit()
 
         except sqlite3.Error as e:
-            if self._verbose:
-                self._printer.print(
-                    content=f"MEMORY ERROR: An error occurred while deleting all rows in LTM: {e}",
-                    color="red",
-                )
+            self._printer.print(
+                content=f"MEMORY ERROR: An error occurred while deleting all rows in LTM: {e}",
+                color="red",
+            )
 
     async def asave(
         self,
@@ -153,11 +147,10 @@ class LTMSQLiteStorage:
                 )
                 await conn.commit()
         except aiosqlite.Error as e:
-            if self._verbose:
-                self._printer.print(
-                    content=f"MEMORY ERROR: An error occurred while saving to LTM: {e}",
-                    color="red",
-                )
+            self._printer.print(
+                content=f"MEMORY ERROR: An error occurred while saving to LTM: {e}",
+                color="red",
+            )
 
     async def aload(
         self, task_description: str, latest_n: int
@@ -194,11 +187,10 @@ class LTMSQLiteStorage:
                         for row in rows
                     ]
         except aiosqlite.Error as e:
-            if self._verbose:
-                self._printer.print(
-                    content=f"MEMORY ERROR: An error occurred while querying LTM: {e}",
-                    color="red",
-                )
+            self._printer.print(
+                content=f"MEMORY ERROR: An error occurred while querying LTM: {e}",
+                color="red",
+            )
         return None
 
     async def areset(self) -> None:
@@ -208,8 +200,7 @@ class LTMSQLiteStorage:
                 await conn.execute("DELETE FROM long_term_memories")
                 await conn.commit()
         except aiosqlite.Error as e:
-            if self._verbose:
-                self._printer.print(
-                    content=f"MEMORY ERROR: An error occurred while deleting all rows in LTM: {e}",
-                    color="red",
-                )
+            self._printer.print(
+                content=f"MEMORY ERROR: An error occurred while deleting all rows in LTM: {e}",
+                color="red",
+            )

lib/crewai/src/crewai/rag/chromadb/config.py

@@ -41,7 +41,6 @@ def _default_settings() -> Settings:
         persist_directory=DEFAULT_STORAGE_PATH,
         allow_reset=True,
         is_persistent=True,
-        anonymized_telemetry=False,
     )
 
 

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

@@ -18,6 +18,7 @@ if TYPE_CHECKING:
     )
     from chromadb.utils.embedding_functions.google_embedding_function import (
         GoogleGenerativeAiEmbeddingFunction,
+        GoogleVertexEmbeddingFunction,
     )
     from chromadb.utils.embedding_functions.huggingface_embedding_function import (
         HuggingFaceEmbeddingFunction,
@@ -51,9 +52,6 @@ if TYPE_CHECKING:
     from crewai.rag.embeddings.providers.aws.types import BedrockProviderSpec
     from crewai.rag.embeddings.providers.cohere.types import CohereProviderSpec
     from crewai.rag.embeddings.providers.custom.types import CustomProviderSpec
-    from crewai.rag.embeddings.providers.google.genai_vertex_embedding import (
-        GoogleGenAIVertexEmbeddingFunction,
-    )
     from crewai.rag.embeddings.providers.google.types import (
         GenerativeAiProviderSpec,
         VertexAIProviderSpec,
@@ -165,7 +163,7 @@ def build_embedder_from_dict(spec: OpenAIProviderSpec) -> OpenAIEmbeddingFunctio
 @overload
 def build_embedder_from_dict(
     spec: VertexAIProviderSpec,
-) -> GoogleGenAIVertexEmbeddingFunction: ...
+) -> GoogleVertexEmbeddingFunction: ...
 
 
 @overload
@@ -298,9 +296,7 @@ def build_embedder(spec: OpenAIProviderSpec) -> OpenAIEmbeddingFunction: ...
 
 
 @overload
-def build_embedder(
-    spec: VertexAIProviderSpec,
-) -> GoogleGenAIVertexEmbeddingFunction: ...
+def build_embedder(spec: VertexAIProviderSpec) -> GoogleVertexEmbeddingFunction: ...
 
 
 @overload

lib/crewai/src/crewai/rag/embeddings/providers/google/__init__.py

@@ -1,8 +1,5 @@
 """Google embedding providers."""
 
-from crewai.rag.embeddings.providers.google.genai_vertex_embedding import (
-    GoogleGenAIVertexEmbeddingFunction,
-)
 from crewai.rag.embeddings.providers.google.generative_ai import (
     GenerativeAiProvider,
 )
@@ -21,7 +18,6 @@ __all__ = [
     "GenerativeAiProvider",
     "GenerativeAiProviderConfig",
     "GenerativeAiProviderSpec",
-    "GoogleGenAIVertexEmbeddingFunction",
     "VertexAIProvider",
     "VertexAIProviderConfig",
     "VertexAIProviderSpec",