fix: replace unsafe ast.literal_eval() with secure alternative to prevent code injection

- Remove unsafe ast.literal_eval() usage in _validate_tool_input method
- Implement _safe_literal_parse() with strict input validation
- Add dangerous pattern detection to block __import__, exec, eval, lambda, etc.
- Support limited Python literal syntax (strings, numbers, booleans, None, lists, dicts)
- Only allow specific safe characters in input
- Maintain backward compatibility for valid tool inputs

Fixes security vulnerability where malicious tool_input could execute arbitrary Python code.

Co-authored-by: factory-droid[bot] <138933559+factory-droid[bot]@users.noreply.github.com>

.github/codeql/codeql-config.yml

@@ -0,0 +1,21 @@
+name: "CodeQL Config"
+
+paths-ignore:
+  # Ignore template files - these are boilerplate code that shouldn't be analyzed
+  - "src/crewai/cli/templates/**"
+  # Ignore test cassettes - these are test fixtures/recordings
+  - "tests/cassettes/**"
+  # Ignore cache and build artifacts
+  - ".cache/**"
+  # Ignore documentation build artifacts
+  - "docs/.cache/**"
+  
+paths:
+  # Include all Python source code
+  - "src/**"
+  # Include tests (but exclude cassettes)
+  - "tests/**"
+
+# Configure specific queries or packs if needed
+# queries:
+#   - uses: security-and-quality

.github/security.md

@@ -1,27 +1,50 @@
-## CrewAI Security Vulnerability Reporting Policy
+## CrewAI Security Policy
 
-CrewAI prioritizes the security of our software products, services, and GitHub repositories. To promptly address vulnerabilities, follow these steps for reporting security issues:
+We are committed to protecting the confidentiality, integrity, and availability of the CrewAI ecosystem. This policy explains how to report potential vulnerabilities and what you can expect from us when you do.
 
-### Reporting Process
-Do **not** report vulnerabilities via public GitHub issues.
+### Scope
 
-Email all vulnerability reports directly to:  
-**security@crewai.com**
+We welcome reports for vulnerabilities that could impact:
 
-### Required Information
-To help us quickly validate and remediate the issue, your report must include:
+- CrewAI-maintained source code and repositories
+- CrewAI-operated infrastructure and services
+- Official CrewAI releases, packages, and distributions
 
-- **Vulnerability Type:** Clearly state the vulnerability type (e.g., SQL injection, XSS, privilege escalation).
-- **Affected Source Code:** Provide full file paths and direct URLs (branch, tag, or commit).
-- **Reproduction Steps:** Include detailed, step-by-step instructions. Screenshots are recommended.
-- **Special Configuration:** Document any special settings or configurations required to reproduce.
-- **Proof-of-Concept (PoC):** Provide exploit or PoC code (if available).
-- **Impact Assessment:** Clearly explain the severity and potential exploitation scenarios.
+Issues affecting clearly unaffiliated third-party services or user-generated content are out of scope, unless you can demonstrate a direct impact on CrewAI systems or customers.
 
-### Our Response
-- We will acknowledge receipt of your report promptly via your provided email.
-- Confirmed vulnerabilities will receive priority remediation based on severity.
-- Patches will be released as swiftly as possible following verification.
+### How to Report
 
-### Reward Notice
-Currently, we do not offer a bug bounty program. Rewards, if issued, are discretionary.
+- **Please do not** disclose vulnerabilities via public GitHub issues, pull requests, or social media.
+- Email detailed reports to **security@crewai.com** with the subject line `Security Report`.
+- If you need to share large files or sensitive artifacts, mention it in your email and we will coordinate a secure transfer method.
+
+### What to Include
+
+Providing comprehensive information enables us to validate the issue quickly:
+
+- **Vulnerability overview** — a concise description and classification (e.g., RCE, privilege escalation)
+- **Affected components** — repository, branch, tag, or deployed service along with relevant file paths or endpoints
+- **Reproduction steps** — detailed, step-by-step instructions; include logs, screenshots, or screen recordings when helpful
+- **Proof-of-concept** — exploit details or code that demonstrates the impact (if available)
+- **Impact analysis** — severity assessment, potential exploitation scenarios, and any prerequisites or special configurations
+
+### Our Commitment
+
+- **Acknowledgement:** We aim to acknowledge your report within two business days.
+- **Communication:** We will keep you informed about triage results, remediation progress, and planned release timelines.
+- **Resolution:** Confirmed vulnerabilities will be prioritized based on severity and fixed as quickly as possible.
+- **Recognition:** We currently do not run a bug bounty program; any rewards or recognition are issued at CrewAI's discretion.
+
+### Coordinated Disclosure
+
+We ask that you allow us a reasonable window to investigate and remediate confirmed issues before any public disclosure. We will coordinate publication timelines with you whenever possible.
+
+### Safe Harbor
+
+We will not pursue or support legal action against individuals who, in good faith:
+
+- Follow this policy and refrain from violating any applicable laws
+- Avoid privacy violations, data destruction, or service disruption
+- Limit testing to systems in scope and respect rate limits and terms of service
+
+If you are unsure whether your testing is covered, please contact us at **security@crewai.com** before proceeding.

.github/workflows/build-uv-cache.yml

@@ -7,6 +7,8 @@ on:
     paths:
       - "uv.lock"
       - "pyproject.toml"
+  schedule:
+    - cron: "0 0 */5 * *"  # Run every 5 days at midnight UTC to prevent cache expiration
   workflow_dispatch:
 
 permissions:

.github/workflows/codeql.yml

@@ -73,6 +73,7 @@ jobs:
       with:
         languages: ${{ matrix.language }}
         build-mode: ${{ matrix.build-mode }}
+        config-file: ./.github/codeql/codeql-config.yml
         # If you wish to specify custom queries, you can do so here or in a config file.
         # By default, queries listed here will override any specified in a config file.
         # Prefix the list here with "+" to use these queries and those in the config file.

README.md

@@ -775,3 +775,4 @@ A: Yes, CrewAI provides extensive beginner-friendly tutorials, courses, and docu
 ### Q: Can CrewAI automate human-in-the-loop workflows?
 
 A: Yes, CrewAI fully supports human-in-the-loop workflows, allowing seamless collaboration between human experts and AI agents for enhanced decision-making.
+# test

docs/docs.json

@@ -397,6 +397,7 @@
                   "en/enterprise/guides/kickoff-crew",
                   "en/enterprise/guides/update-crew",
                   "en/enterprise/guides/enable-crew-studio",
+                  "en/enterprise/guides/capture_telemetry_logs",
                   "en/enterprise/guides/azure-openai-setup",
                   "en/enterprise/guides/tool-repository",
                   "en/enterprise/guides/react-component-export",
@@ -421,6 +422,7 @@
                   "en/api-reference/introduction",
                   "en/api-reference/inputs",
                   "en/api-reference/kickoff",
+                  "en/api-reference/resume",
                   "en/api-reference/status"
                 ]
               }
@@ -827,6 +829,7 @@
                   "pt-BR/api-reference/introduction",
                   "pt-BR/api-reference/inputs",
                   "pt-BR/api-reference/kickoff",
+                  "pt-BR/api-reference/resume",
                   "pt-BR/api-reference/status"
                 ]
               }
@@ -1239,6 +1242,7 @@
                   "ko/api-reference/introduction",
                   "ko/api-reference/inputs",
                   "ko/api-reference/kickoff",
+                  "ko/api-reference/resume",
                   "ko/api-reference/status"
                 ]
               }

docs/en/api-reference/resume.mdx

@@ -0,0 +1,6 @@
+---
+title: "POST /resume"
+description: "Resume crew execution with human feedback"
+openapi: "/enterprise-api.en.yaml POST /resume"
+mode: "wide"
+---

docs/en/enterprise/guides/capture_telemetry_logs.mdx

@@ -0,0 +1,35 @@
+---
+title: "Open Telemetry Logs"
+description: "Understand how to capture telemetry logs from your CrewAI AMP deployments"
+icon: "magnifying-glass-chart"
+mode: "wide"
+---
+
+CrewAI AMP provides a powerful way to capture telemetry logs from your deployments. This allows you to monitor the performance of your agents and workflows, and to debug issues that may arise.
+
+## Prerequisites
+
+<CardGroup cols={2}>
+  <Card title="ENTERPRISE OTEL SETUP enabled" icon="users">
+    Your organization should have ENTERPRISE OTEL SETUP enabled
+  </Card>
+  <Card title="OTEL collector setup" icon="server">
+    Your organization should have an OTEL collector setup or a provider like Datadog log intake setup
+  </Card>
+</CardGroup>
+
+
+## How to capture telemetry logs
+
+1. Go to settings/organization tab
+2. Configure your OTEL collector setup
+3. Save
+
+
+
+Example to setup OTEL log collection capture to Datadog.
+
+
+<Frame>
+  ![Capture Telemetry Logs](/images/crewai-otel-export.png)
+</Frame>

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

@@ -40,6 +40,28 @@ Human-In-The-Loop (HITL) is a powerful approach that combines artificial intelli
         <Frame>
             <img src="/images/enterprise/crew-resume-endpoint.png" alt="Crew Resume Endpoint" />
         </Frame>
+
+        <Warning>
+            **Critical: Webhook URLs Must Be Provided Again**:
+            You **must** provide the same webhook URLs (`taskWebhookUrl`, `stepWebhookUrl`, `crewWebhookUrl`) in the resume call that you used in the kickoff call. Webhook configurations are **NOT** automatically carried over from kickoff - they must be explicitly included in the resume request to continue receiving notifications for task completion, agent steps, and crew completion.
+        </Warning>
+
+        Example resume call with webhooks:
+        ```bash
+        curl -X POST {BASE_URL}/resume \
+          -H "Authorization: Bearer YOUR_API_TOKEN" \
+          -H "Content-Type: application/json" \
+          -d '{
+            "execution_id": "abcd1234-5678-90ef-ghij-klmnopqrstuv",
+            "task_id": "research_task",
+            "human_feedback": "Great work! Please add more details.",
+            "is_approve": true,
+            "taskWebhookUrl": "https://your-server.com/webhooks/task",
+            "stepWebhookUrl": "https://your-server.com/webhooks/step",
+            "crewWebhookUrl": "https://your-server.com/webhooks/crew"
+          }'
+        ```
+
         <Warning>
             **Feedback Impact on Task Execution**:
             It's crucial to exercise care when providing feedback, as the entire feedback content will be incorporated as additional context for further task executions.
@@ -76,4 +98,4 @@ HITL workflows are particularly valuable for:
 - Complex decision-making scenarios
 - Sensitive or high-stakes operations
 - Creative tasks requiring human judgment
-- Compliance and regulatory reviews 
+- Compliance and regulatory reviews

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

@@ -79,6 +79,28 @@ Human-in-the-Loop (HITL) is a powerful approach that combines artificial intelli
         <Frame>
             <img src="/images/enterprise/crew-resume-endpoint.png" alt="Crew Resume Endpoint" />
         </Frame>
+
+        <Warning>
+            **Critical: Webhook URLs Must Be Provided Again**:
+            You **must** provide the same webhook URLs (`taskWebhookUrl`, `stepWebhookUrl`, `crewWebhookUrl`) in the resume call that you used in the kickoff call. Webhook configurations are **NOT** automatically carried over from kickoff - they must be explicitly included in the resume request to continue receiving notifications for task completion, agent steps, and crew completion.
+        </Warning>
+
+        Example resume call with webhooks:
+        ```bash
+        curl -X POST {BASE_URL}/resume \
+          -H "Authorization: Bearer YOUR_API_TOKEN" \
+          -H "Content-Type: application/json" \
+          -d '{
+            "execution_id": "abcd1234-5678-90ef-ghij-klmnopqrstuv",
+            "task_id": "research_task",
+            "human_feedback": "Great work! Please add more details.",
+            "is_approve": true,
+            "taskWebhookUrl": "https://your-server.com/webhooks/task",
+            "stepWebhookUrl": "https://your-server.com/webhooks/step",
+            "crewWebhookUrl": "https://your-server.com/webhooks/crew"
+          }'
+        ```
+
         <Warning>
             **Feedback Impact on Task Execution**:
             It's crucial to exercise care when providing feedback, as the entire feedback content will be incorporated as additional context for further task executions.

docs/enterprise-api.base.yaml

@@ -276,6 +276,134 @@ paths:
         '500':
           $ref: '#/components/responses/ServerError'
 
+  /resume:
+    post:
+      summary: Resume Crew Execution with Human Feedback
+      description: |
+        **📋 Reference Example Only** - *This shows the request format. To test with your actual crew, copy the cURL example and replace the URL + token with your real values.*
+
+        Resume a paused crew execution with human feedback for Human-in-the-Loop (HITL) workflows.
+        When a task with `human_input=True` completes, the crew execution pauses and waits for human feedback.
+
+        **IMPORTANT**: You must provide the same webhook URLs (`taskWebhookUrl`, `stepWebhookUrl`, `crewWebhookUrl`)
+        that were used in the original kickoff call. Webhook configurations are NOT automatically carried over -
+        they must be explicitly provided in the resume request to continue receiving notifications.
+      operationId: resumeCrewExecution
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              required:
+                - execution_id
+                - task_id
+                - human_feedback
+                - is_approve
+              properties:
+                execution_id:
+                  type: string
+                  format: uuid
+                  description: The unique identifier for the crew execution (from kickoff)
+                  example: "abcd1234-5678-90ef-ghij-klmnopqrstuv"
+                task_id:
+                  type: string
+                  description: The ID of the task that requires human feedback
+                  example: "research_task"
+                human_feedback:
+                  type: string
+                  description: Your feedback on the task output. This will be incorporated as additional context for subsequent task executions.
+                  example: "Great research! Please add more details about recent developments in the field."
+                is_approve:
+                  type: boolean
+                  description: "Whether you approve the task output: true = positive feedback (continue), false = negative feedback (retry task)"
+                  example: true
+                taskWebhookUrl:
+                  type: string
+                  format: uri
+                  description: Callback URL executed after each task completion. MUST be provided to continue receiving task notifications.
+                  example: "https://your-server.com/webhooks/task"
+                stepWebhookUrl:
+                  type: string
+                  format: uri
+                  description: Callback URL executed after each agent thought/action. MUST be provided to continue receiving step notifications.
+                  example: "https://your-server.com/webhooks/step"
+                crewWebhookUrl:
+                  type: string
+                  format: uri
+                  description: Callback URL executed when the crew execution completes. MUST be provided to receive completion notification.
+                  example: "https://your-server.com/webhooks/crew"
+            examples:
+              approve_and_continue:
+                summary: Approve task and continue execution
+                value:
+                  execution_id: "abcd1234-5678-90ef-ghij-klmnopqrstuv"
+                  task_id: "research_task"
+                  human_feedback: "Excellent research! Proceed to the next task."
+                  is_approve: true
+                  taskWebhookUrl: "https://api.example.com/webhooks/task"
+                  stepWebhookUrl: "https://api.example.com/webhooks/step"
+                  crewWebhookUrl: "https://api.example.com/webhooks/crew"
+              request_revision:
+                summary: Request task revision with feedback
+                value:
+                  execution_id: "abcd1234-5678-90ef-ghij-klmnopqrstuv"
+                  task_id: "analysis_task"
+                  human_feedback: "Please include more quantitative data and cite your sources."
+                  is_approve: false
+                  taskWebhookUrl: "https://api.example.com/webhooks/task"
+                  crewWebhookUrl: "https://api.example.com/webhooks/crew"
+      responses:
+        '200':
+          description: Execution resumed successfully
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  status:
+                    type: string
+                    enum: ["resumed", "retrying", "completed"]
+                    description: Status of the resumed execution
+                    example: "resumed"
+                  message:
+                    type: string
+                    description: Human-readable message about the resume operation
+                    example: "Execution resumed successfully"
+              examples:
+                resumed:
+                  summary: Execution resumed with positive feedback
+                  value:
+                    status: "resumed"
+                    message: "Execution resumed successfully"
+                retrying:
+                  summary: Task will be retried with negative feedback
+                  value:
+                    status: "retrying"
+                    message: "Task will be retried with your feedback"
+        '400':
+          description: Invalid request body or execution not in pending state
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Error'
+              example:
+                error: "Invalid Request"
+                message: "Execution is not in pending human input state"
+        '401':
+          $ref: '#/components/responses/UnauthorizedError'
+        '404':
+          description: Execution ID or Task ID not found
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Error'
+              example:
+                error: "Not Found"
+                message: "Execution ID not found"
+        '500':
+          $ref: '#/components/responses/ServerError'
+
 components:
   securitySchemes:
     BearerAuth:

docs/enterprise-api.en.yaml

@@ -276,6 +276,134 @@ paths:
         '500':
           $ref: '#/components/responses/ServerError'
 
+  /resume:
+    post:
+      summary: Resume Crew Execution with Human Feedback
+      description: |
+        **📋 Reference Example Only** - *This shows the request format. To test with your actual crew, copy the cURL example and replace the URL + token with your real values.*
+
+        Resume a paused crew execution with human feedback for Human-in-the-Loop (HITL) workflows.
+        When a task with `human_input=True` completes, the crew execution pauses and waits for human feedback.
+
+        **IMPORTANT**: You must provide the same webhook URLs (`taskWebhookUrl`, `stepWebhookUrl`, `crewWebhookUrl`)
+        that were used in the original kickoff call. Webhook configurations are NOT automatically carried over -
+        they must be explicitly provided in the resume request to continue receiving notifications.
+      operationId: resumeCrewExecution
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              required:
+                - execution_id
+                - task_id
+                - human_feedback
+                - is_approve
+              properties:
+                execution_id:
+                  type: string
+                  format: uuid
+                  description: The unique identifier for the crew execution (from kickoff)
+                  example: "abcd1234-5678-90ef-ghij-klmnopqrstuv"
+                task_id:
+                  type: string
+                  description: The ID of the task that requires human feedback
+                  example: "research_task"
+                human_feedback:
+                  type: string
+                  description: Your feedback on the task output. This will be incorporated as additional context for subsequent task executions.
+                  example: "Great research! Please add more details about recent developments in the field."
+                is_approve:
+                  type: boolean
+                  description: "Whether you approve the task output: true = positive feedback (continue), false = negative feedback (retry task)"
+                  example: true
+                taskWebhookUrl:
+                  type: string
+                  format: uri
+                  description: Callback URL executed after each task completion. MUST be provided to continue receiving task notifications.
+                  example: "https://your-server.com/webhooks/task"
+                stepWebhookUrl:
+                  type: string
+                  format: uri
+                  description: Callback URL executed after each agent thought/action. MUST be provided to continue receiving step notifications.
+                  example: "https://your-server.com/webhooks/step"
+                crewWebhookUrl:
+                  type: string
+                  format: uri
+                  description: Callback URL executed when the crew execution completes. MUST be provided to receive completion notification.
+                  example: "https://your-server.com/webhooks/crew"
+            examples:
+              approve_and_continue:
+                summary: Approve task and continue execution
+                value:
+                  execution_id: "abcd1234-5678-90ef-ghij-klmnopqrstuv"
+                  task_id: "research_task"
+                  human_feedback: "Excellent research! Proceed to the next task."
+                  is_approve: true
+                  taskWebhookUrl: "https://api.example.com/webhooks/task"
+                  stepWebhookUrl: "https://api.example.com/webhooks/step"
+                  crewWebhookUrl: "https://api.example.com/webhooks/crew"
+              request_revision:
+                summary: Request task revision with feedback
+                value:
+                  execution_id: "abcd1234-5678-90ef-ghij-klmnopqrstuv"
+                  task_id: "analysis_task"
+                  human_feedback: "Please include more quantitative data and cite your sources."
+                  is_approve: false
+                  taskWebhookUrl: "https://api.example.com/webhooks/task"
+                  crewWebhookUrl: "https://api.example.com/webhooks/crew"
+      responses:
+        '200':
+          description: Execution resumed successfully
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  status:
+                    type: string
+                    enum: ["resumed", "retrying", "completed"]
+                    description: Status of the resumed execution
+                    example: "resumed"
+                  message:
+                    type: string
+                    description: Human-readable message about the resume operation
+                    example: "Execution resumed successfully"
+              examples:
+                resumed:
+                  summary: Execution resumed with positive feedback
+                  value:
+                    status: "resumed"
+                    message: "Execution resumed successfully"
+                retrying:
+                  summary: Task will be retried with negative feedback
+                  value:
+                    status: "retrying"
+                    message: "Task will be retried with your feedback"
+        '400':
+          description: Invalid request body or execution not in pending state
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Error'
+              example:
+                error: "Invalid Request"
+                message: "Execution is not in pending human input state"
+        '401':
+          $ref: '#/components/responses/UnauthorizedError'
+        '404':
+          description: Execution ID or Task ID not found
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Error'
+              example:
+                error: "Not Found"
+                message: "Execution ID not found"
+        '500':
+          $ref: '#/components/responses/ServerError'
+
 components:
   securitySchemes:
     BearerAuth:

docs/enterprise-api.ko.yaml

@@ -120,6 +120,134 @@ paths:
         '500':
           $ref: '#/components/responses/ServerError'
 
+  /resume:
+    post:
+      summary: Resume Crew Execution with Human Feedback
+      description: |
+        **📋 Reference Example Only** - *This shows the request format. To test with your actual crew, copy the cURL example and replace the URL + token with your real values.*
+
+        Resume a paused crew execution with human feedback for Human-in-the-Loop (HITL) workflows.
+        When a task with `human_input=True` completes, the crew execution pauses and waits for human feedback.
+
+        **IMPORTANT**: You must provide the same webhook URLs (`taskWebhookUrl`, `stepWebhookUrl`, `crewWebhookUrl`)
+        that were used in the original kickoff call. Webhook configurations are NOT automatically carried over -
+        they must be explicitly provided in the resume request to continue receiving notifications.
+      operationId: resumeCrewExecution
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              required:
+                - execution_id
+                - task_id
+                - human_feedback
+                - is_approve
+              properties:
+                execution_id:
+                  type: string
+                  format: uuid
+                  description: The unique identifier for the crew execution (from kickoff)
+                  example: "abcd1234-5678-90ef-ghij-klmnopqrstuv"
+                task_id:
+                  type: string
+                  description: The ID of the task that requires human feedback
+                  example: "research_task"
+                human_feedback:
+                  type: string
+                  description: Your feedback on the task output. This will be incorporated as additional context for subsequent task executions.
+                  example: "Great research! Please add more details about recent developments in the field."
+                is_approve:
+                  type: boolean
+                  description: "Whether you approve the task output: true = positive feedback (continue), false = negative feedback (retry task)"
+                  example: true
+                taskWebhookUrl:
+                  type: string
+                  format: uri
+                  description: Callback URL executed after each task completion. MUST be provided to continue receiving task notifications.
+                  example: "https://your-server.com/webhooks/task"
+                stepWebhookUrl:
+                  type: string
+                  format: uri
+                  description: Callback URL executed after each agent thought/action. MUST be provided to continue receiving step notifications.
+                  example: "https://your-server.com/webhooks/step"
+                crewWebhookUrl:
+                  type: string
+                  format: uri
+                  description: Callback URL executed when the crew execution completes. MUST be provided to receive completion notification.
+                  example: "https://your-server.com/webhooks/crew"
+            examples:
+              approve_and_continue:
+                summary: Approve task and continue execution
+                value:
+                  execution_id: "abcd1234-5678-90ef-ghij-klmnopqrstuv"
+                  task_id: "research_task"
+                  human_feedback: "Excellent research! Proceed to the next task."
+                  is_approve: true
+                  taskWebhookUrl: "https://api.example.com/webhooks/task"
+                  stepWebhookUrl: "https://api.example.com/webhooks/step"
+                  crewWebhookUrl: "https://api.example.com/webhooks/crew"
+              request_revision:
+                summary: Request task revision with feedback
+                value:
+                  execution_id: "abcd1234-5678-90ef-ghij-klmnopqrstuv"
+                  task_id: "analysis_task"
+                  human_feedback: "Please include more quantitative data and cite your sources."
+                  is_approve: false
+                  taskWebhookUrl: "https://api.example.com/webhooks/task"
+                  crewWebhookUrl: "https://api.example.com/webhooks/crew"
+      responses:
+        '200':
+          description: Execution resumed successfully
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  status:
+                    type: string
+                    enum: ["resumed", "retrying", "completed"]
+                    description: Status of the resumed execution
+                    example: "resumed"
+                  message:
+                    type: string
+                    description: Human-readable message about the resume operation
+                    example: "Execution resumed successfully"
+              examples:
+                resumed:
+                  summary: Execution resumed with positive feedback
+                  value:
+                    status: "resumed"
+                    message: "Execution resumed successfully"
+                retrying:
+                  summary: Task will be retried with negative feedback
+                  value:
+                    status: "retrying"
+                    message: "Task will be retried with your feedback"
+        '400':
+          description: Invalid request body or execution not in pending state
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Error'
+              example:
+                error: "Invalid Request"
+                message: "Execution is not in pending human input state"
+        '401':
+          $ref: '#/components/responses/UnauthorizedError'
+        '404':
+          description: Execution ID or Task ID not found
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Error'
+              example:
+                error: "Not Found"
+                message: "Execution ID not found"
+        '500':
+          $ref: '#/components/responses/ServerError'
+
 components:
   securitySchemes:
     BearerAuth:

docs/enterprise-api.pt-BR.yaml

@@ -156,6 +156,134 @@ paths:
         '500':
           $ref: '#/components/responses/ServerError'
 
+  /resume:
+    post:
+      summary: Resume Crew Execution with Human Feedback
+      description: |
+        **📋 Reference Example Only** - *This shows the request format. To test with your actual crew, copy the cURL example and replace the URL + token with your real values.*
+
+        Resume a paused crew execution with human feedback for Human-in-the-Loop (HITL) workflows.
+        When a task with `human_input=True` completes, the crew execution pauses and waits for human feedback.
+
+        **IMPORTANT**: You must provide the same webhook URLs (`taskWebhookUrl`, `stepWebhookUrl`, `crewWebhookUrl`)
+        that were used in the original kickoff call. Webhook configurations are NOT automatically carried over -
+        they must be explicitly provided in the resume request to continue receiving notifications.
+      operationId: resumeCrewExecution
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              required:
+                - execution_id
+                - task_id
+                - human_feedback
+                - is_approve
+              properties:
+                execution_id:
+                  type: string
+                  format: uuid
+                  description: The unique identifier for the crew execution (from kickoff)
+                  example: "abcd1234-5678-90ef-ghij-klmnopqrstuv"
+                task_id:
+                  type: string
+                  description: The ID of the task that requires human feedback
+                  example: "research_task"
+                human_feedback:
+                  type: string
+                  description: Your feedback on the task output. This will be incorporated as additional context for subsequent task executions.
+                  example: "Great research! Please add more details about recent developments in the field."
+                is_approve:
+                  type: boolean
+                  description: "Whether you approve the task output: true = positive feedback (continue), false = negative feedback (retry task)"
+                  example: true
+                taskWebhookUrl:
+                  type: string
+                  format: uri
+                  description: Callback URL executed after each task completion. MUST be provided to continue receiving task notifications.
+                  example: "https://your-server.com/webhooks/task"
+                stepWebhookUrl:
+                  type: string
+                  format: uri
+                  description: Callback URL executed after each agent thought/action. MUST be provided to continue receiving step notifications.
+                  example: "https://your-server.com/webhooks/step"
+                crewWebhookUrl:
+                  type: string
+                  format: uri
+                  description: Callback URL executed when the crew execution completes. MUST be provided to receive completion notification.
+                  example: "https://your-server.com/webhooks/crew"
+            examples:
+              approve_and_continue:
+                summary: Approve task and continue execution
+                value:
+                  execution_id: "abcd1234-5678-90ef-ghij-klmnopqrstuv"
+                  task_id: "research_task"
+                  human_feedback: "Excellent research! Proceed to the next task."
+                  is_approve: true
+                  taskWebhookUrl: "https://api.example.com/webhooks/task"
+                  stepWebhookUrl: "https://api.example.com/webhooks/step"
+                  crewWebhookUrl: "https://api.example.com/webhooks/crew"
+              request_revision:
+                summary: Request task revision with feedback
+                value:
+                  execution_id: "abcd1234-5678-90ef-ghij-klmnopqrstuv"
+                  task_id: "analysis_task"
+                  human_feedback: "Please include more quantitative data and cite your sources."
+                  is_approve: false
+                  taskWebhookUrl: "https://api.example.com/webhooks/task"
+                  crewWebhookUrl: "https://api.example.com/webhooks/crew"
+      responses:
+        '200':
+          description: Execution resumed successfully
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  status:
+                    type: string
+                    enum: ["resumed", "retrying", "completed"]
+                    description: Status of the resumed execution
+                    example: "resumed"
+                  message:
+                    type: string
+                    description: Human-readable message about the resume operation
+                    example: "Execution resumed successfully"
+              examples:
+                resumed:
+                  summary: Execution resumed with positive feedback
+                  value:
+                    status: "resumed"
+                    message: "Execution resumed successfully"
+                retrying:
+                  summary: Task will be retried with negative feedback
+                  value:
+                    status: "retrying"
+                    message: "Task will be retried with your feedback"
+        '400':
+          description: Invalid request body or execution not in pending state
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Error'
+              example:
+                error: "Invalid Request"
+                message: "Execution is not in pending human input state"
+        '401':
+          $ref: '#/components/responses/UnauthorizedError'
+        '404':
+          description: Execution ID or Task ID not found
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Error'
+              example:
+                error: "Not Found"
+                message: "Execution ID not found"
+        '500':
+          $ref: '#/components/responses/ServerError'
+
 components:
   securitySchemes:
     BearerAuth:

docs/ko/api-reference/resume.mdx

@@ -0,0 +1,6 @@
+---
+title: "POST /resume"
+description: "인간 피드백으로 crew 실행 재개"
+openapi: "/enterprise-api.ko.yaml POST /resume"
+mode: "wide"
+---

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

@@ -40,6 +40,28 @@ mode: "wide"
         <Frame>
             <img src="/images/enterprise/crew-resume-endpoint.png" alt="Crew Resume Endpoint" />
         </Frame>
+
+        <Warning>
+            **중요: Webhook URL을 다시 제공해야 합니다**:
+            kickoff 호출에서 사용한 것과 동일한 webhook URL(`taskWebhookUrl`, `stepWebhookUrl`, `crewWebhookUrl`)을 resume 호출에서 **반드시** 제공해야 합니다. Webhook 설정은 kickoff에서 자동으로 전달되지 **않으므로**, 작업 완료, 에이전트 단계, crew 완료에 대한 알림을 계속 받으려면 resume 요청에 명시적으로 포함해야 합니다.
+        </Warning>
+
+        Webhook을 포함한 resume 호출 예시:
+        ```bash
+        curl -X POST {BASE_URL}/resume \
+          -H "Authorization: Bearer YOUR_API_TOKEN" \
+          -H "Content-Type: application/json" \
+          -d '{
+            "execution_id": "abcd1234-5678-90ef-ghij-klmnopqrstuv",
+            "task_id": "research_task",
+            "human_feedback": "훌륭한 작업입니다! 더 자세한 내용을 추가해주세요.",
+            "is_approve": true,
+            "taskWebhookUrl": "https://your-server.com/webhooks/task",
+            "stepWebhookUrl": "https://your-server.com/webhooks/step",
+            "crewWebhookUrl": "https://your-server.com/webhooks/crew"
+          }'
+        ```
+
         <Warning>
             **피드백이 작업 실행에 미치는 영향**:
             피드백 전체 내용이 이후 작업 실행을 위한 추가 컨텍스트로 통합되므로 피드백 제공 시 신중함이 매우 중요합니다.
@@ -76,4 +98,4 @@ HITL 워크플로우는 특히 다음과 같은 경우에 유용합니다:
 - 복잡한 의사 결정 시나리오
 - 민감하거나 위험도가 높은 작업
 - 인간의 판단이 필요한 창의적 작업
-- 준수 및 규제 검토
+- 준수 및 규제 검토

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

@@ -40,6 +40,28 @@ mode: "wide"
         <Frame>
             <img src="/images/enterprise/crew-resume-endpoint.png" alt="Crew Resume Endpoint" />
         </Frame>
+
+        <Warning>
+            **중요: Webhook URL을 다시 제공해야 합니다**:
+            kickoff 호출에서 사용한 것과 동일한 webhook URL(`taskWebhookUrl`, `stepWebhookUrl`, `crewWebhookUrl`)을 resume 호출에서 **반드시** 제공해야 합니다. Webhook 설정은 kickoff에서 자동으로 전달되지 **않으므로**, 작업 완료, 에이전트 단계, crew 완료에 대한 알림을 계속 받으려면 resume 요청에 명시적으로 포함해야 합니다.
+        </Warning>
+
+        Webhook을 포함한 resume 호출 예시:
+        ```bash
+        curl -X POST {BASE_URL}/resume \
+          -H "Authorization: Bearer YOUR_API_TOKEN" \
+          -H "Content-Type: application/json" \
+          -d '{
+            "execution_id": "abcd1234-5678-90ef-ghij-klmnopqrstuv",
+            "task_id": "research_task",
+            "human_feedback": "훌륭한 작업입니다! 더 자세한 내용을 추가해주세요.",
+            "is_approve": true,
+            "taskWebhookUrl": "https://your-server.com/webhooks/task",
+            "stepWebhookUrl": "https://your-server.com/webhooks/step",
+            "crewWebhookUrl": "https://your-server.com/webhooks/crew"
+          }'
+        ```
+
         <Warning>
             **피드백이 작업 실행에 미치는 영향**:
             피드백의 전체 내용이 추가 컨텍스트로서 이후 작업 실행에 통합되므로, 피드백 제공 시 신중을 기하는 것이 매우 중요합니다.
@@ -76,4 +98,4 @@ HITL 워크플로우는 다음과 같은 경우에 특히 유용합니다:
 - 복잡한 의사결정 시나리오
 - 민감하거나 고위험 작업
 - 인간의 판단이 필요한 창의적 과제
-- 컴플라이언스 및 규제 검토
+- 컴플라이언스 및 규제 검토

docs/pt-BR/api-reference/resume.mdx

@@ -0,0 +1,6 @@
+---
+title: "POST /resume"
+description: "Retomar execução do crew com feedback humano"
+openapi: "/enterprise-api.pt-BR.yaml POST /resume"
+mode: "wide"
+---

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

@@ -40,6 +40,28 @@ Human-In-The-Loop (HITL) é uma abordagem poderosa que combina inteligência art
         <Frame>
             <img src="/images/enterprise/crew-resume-endpoint.png" alt="Crew Resume Endpoint" />
         </Frame>
+
+        <Warning>
+            **Crítico: URLs de Webhook Devem Ser Fornecidas Novamente**:
+            Você **deve** fornecer as mesmas URLs de webhook (`taskWebhookUrl`, `stepWebhookUrl`, `crewWebhookUrl`) na chamada de resume que você usou na chamada de kickoff. As configurações de webhook **NÃO** são automaticamente transferidas do kickoff - elas devem ser explicitamente incluídas na solicitação de resume para continuar recebendo notificações de conclusão de tarefa, etapas do agente e conclusão do crew.
+        </Warning>
+
+        Exemplo de chamada resume com webhooks:
+        ```bash
+        curl -X POST {BASE_URL}/resume \
+          -H "Authorization: Bearer YOUR_API_TOKEN" \
+          -H "Content-Type: application/json" \
+          -d '{
+            "execution_id": "abcd1234-5678-90ef-ghij-klmnopqrstuv",
+            "task_id": "research_task",
+            "human_feedback": "Ótimo trabalho! Por favor, adicione mais detalhes.",
+            "is_approve": true,
+            "taskWebhookUrl": "https://your-server.com/webhooks/task",
+            "stepWebhookUrl": "https://your-server.com/webhooks/step",
+            "crewWebhookUrl": "https://your-server.com/webhooks/crew"
+          }'
+        ```
+
         <Warning>
             **Impacto do Feedback na Execução da Tarefa**:
             É crucial ter cuidado ao fornecer o feedback, pois todo o conteúdo do feedback será incorporado como contexto adicional para as próximas execuções da tarefa.
@@ -76,4 +98,4 @@ Workflows HITL são particularmente valiosos para:
 - Cenários de tomada de decisão complexa
 - Operações sensíveis ou de alto risco
 - Tarefas criativas que exigem julgamento humano
-- Revisões de conformidade e regulatórias
+- Revisões de conformidade e regulatórias

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

@@ -40,6 +40,28 @@ Human-in-the-Loop (HITL) é uma abordagem poderosa que combina a inteligência a
         <Frame>
             <img src="/images/enterprise/crew-resume-endpoint.png" alt="Endpoint de Retomada Crew" />
         </Frame>
+
+        <Warning>
+            **Crítico: URLs de Webhook Devem Ser Fornecidas Novamente**:
+            Você **deve** fornecer as mesmas URLs de webhook (`taskWebhookUrl`, `stepWebhookUrl`, `crewWebhookUrl`) na chamada de resume que você usou na chamada de kickoff. As configurações de webhook **NÃO** são automaticamente transferidas do kickoff - elas devem ser explicitamente incluídas na solicitação de resume para continuar recebendo notificações de conclusão de tarefa, etapas do agente e conclusão do crew.
+        </Warning>
+
+        Exemplo de chamada resume com webhooks:
+        ```bash
+        curl -X POST {BASE_URL}/resume \
+          -H "Authorization: Bearer YOUR_API_TOKEN" \
+          -H "Content-Type: application/json" \
+          -d '{
+            "execution_id": "abcd1234-5678-90ef-ghij-klmnopqrstuv",
+            "task_id": "research_task",
+            "human_feedback": "Ótimo trabalho! Por favor, adicione mais detalhes.",
+            "is_approve": true,
+            "taskWebhookUrl": "https://your-server.com/webhooks/task",
+            "stepWebhookUrl": "https://your-server.com/webhooks/step",
+            "crewWebhookUrl": "https://your-server.com/webhooks/crew"
+          }'
+        ```
+
         <Warning>
             **Impacto do Feedback na Execução da Tarefa**:
             É fundamental ter cuidado ao fornecer feedback, pois todo o conteúdo do feedback será incorporado como contexto adicional para execuções futuras da tarefa.
@@ -76,4 +98,4 @@ Workflows HITL são particularmente valiosos para:
 - Cenários de tomada de decisão complexa
 - Operações sensíveis ou de alto risco
 - Tarefas criativas que requerem julgamento humano
-- Revisões de conformidade e regulamentação
+- Revisões de conformidade e regulamentação

pyproject.toml

@@ -49,7 +49,7 @@ Repository = "https://github.com/crewAIInc/crewAI"
 
 [project.optional-dependencies]
 tools = [
-    "crewai-tools>=0.74.0",
+    "crewai-tools>=0.76.0",
 ]
 embeddings = [
     "tiktoken~=0.8.0"

src/crewai/__init__.py

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

src/crewai/agent.py

@@ -53,6 +53,7 @@ from crewai.utilities.converter import generate_model_description
 from crewai.utilities.llm_utils import create_llm
 from crewai.utilities.token_counter_callback import TokenCalcHandler
 from crewai.utilities.training_handler import CrewTrainingHandler
+from crewai.utilities.types import LLMMessage
 
 
 class Agent(BaseAgent):
@@ -174,7 +175,7 @@ class Agent(BaseAgent):
     )
 
     @model_validator(mode="before")
-    def validate_from_repository(cls, v): # noqa: N805
+    def validate_from_repository(cls, v):  # noqa: N805
         if v is not None and (from_repository := v.get("from_repository")):
             return load_agent_from_repository(from_repository) | v
         return v
@@ -347,15 +348,16 @@ class Agent(BaseAgent):
         )
 
         if self.knowledge or (self.crew and self.crew.knowledge):
-            crewai_event_bus.emit(
-                self,
-                event=KnowledgeRetrievalStartedEvent(
-                    agent=self,
-                ),
-            )
             try:
                 self.knowledge_search_query = self._get_knowledge_search_query(
-                    task_prompt
+                    task_prompt, task
+                )
+                crewai_event_bus.emit(
+                    self,
+                    event=KnowledgeRetrievalStartedEvent(
+                        from_task=task,
+                        from_agent=self,
+                    ),
                 )
                 if self.knowledge_search_query:
                     # Quering agent specific knowledge
@@ -385,7 +387,8 @@ class Agent(BaseAgent):
                         self,
                         event=KnowledgeRetrievalCompletedEvent(
                             query=self.knowledge_search_query,
-                            agent=self,
+                            from_task=task,
+                            from_agent=self,
                             retrieved_knowledge=(
                                 (self.agent_knowledge_context or "")
                                 + (
@@ -403,8 +406,9 @@ class Agent(BaseAgent):
                     self,
                     event=KnowledgeSearchQueryFailedEvent(
                         query=self.knowledge_search_query or "",
-                        agent=self,
                         error=str(e),
+                        from_task=task,
+                        from_agent=self,
                     ),
                 )
 
@@ -702,7 +706,7 @@ class Agent(BaseAgent):
 
         try:
             subprocess.run(
-                ["/usr/bin/docker", "info"],
+                ["docker", "info"],  # noqa: S607
                 check=True,
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
@@ -728,13 +732,14 @@ class Agent(BaseAgent):
     def set_fingerprint(self, fingerprint: Fingerprint):
         self.security_config.fingerprint = fingerprint
 
-    def _get_knowledge_search_query(self, task_prompt: str) -> str | None:
+    def _get_knowledge_search_query(self, task_prompt: str, task: Task) -> str | None:
         """Generate a search query for the knowledge base based on the task description."""
         crewai_event_bus.emit(
             self,
             event=KnowledgeQueryStartedEvent(
                 task_prompt=task_prompt,
-                agent=self,
+                from_task=task,
+                from_agent=self,
             ),
         )
         query = self.i18n.slice("knowledge_search_query").format(
@@ -749,8 +754,9 @@ class Agent(BaseAgent):
             crewai_event_bus.emit(
                 self,
                 event=KnowledgeQueryFailedEvent(
-                    agent=self,
                     error="LLM is not compatible with knowledge search queries",
+                    from_task=task,
+                    from_agent=self,
                 ),
             )
             return None
@@ -769,7 +775,8 @@ class Agent(BaseAgent):
                 self,
                 event=KnowledgeQueryCompletedEvent(
                     query=query,
-                    agent=self,
+                    from_task=task,
+                    from_agent=self,
                 ),
             )
             return rewritten_query
@@ -777,15 +784,16 @@ class Agent(BaseAgent):
             crewai_event_bus.emit(
                 self,
                 event=KnowledgeQueryFailedEvent(
-                    agent=self,
                     error=str(e),
+                    from_task=task,
+                    from_agent=self,
                 ),
             )
             return None
 
     def kickoff(
         self,
-        messages: str | list[dict[str, str]],
+        messages: str | list[LLMMessage],
         response_format: type[Any] | None = None,
     ) -> LiteAgentOutput:
         """
@@ -825,7 +833,7 @@ class Agent(BaseAgent):
 
     async def kickoff_async(
         self,
-        messages: str | list[dict[str, str]],
+        messages: str | list[LLMMessage],
         response_format: type[Any] | None = None,
     ) -> LiteAgentOutput:
         """
@@ -855,6 +863,7 @@ class Agent(BaseAgent):
             response_format=response_format,
             i18n=self.i18n,
             original_agent=self,
+            guardrail=self.guardrail,
         )
 
         return await lite_agent.kickoff_async(messages)

src/crewai/cli/run_crew.py

@@ -1,10 +1,11 @@
+import os
 import subprocess
 from enum import Enum
 
 import click
 from packaging import version
 
-from crewai.cli.utils import read_toml
+from crewai.cli.utils import build_env_with_tool_repository_credentials, read_toml
 from crewai.cli.version import get_crewai_version
 
 
@@ -55,8 +56,22 @@ def execute_command(crew_type: CrewType) -> None:
     """
     command = ["uv", "run", "kickoff" if crew_type == CrewType.FLOW else "run_crew"]
 
+    env = os.environ.copy()
     try:
-        subprocess.run(command, capture_output=False, text=True, check=True)  # noqa: S603
+        pyproject_data = read_toml()
+        sources = pyproject_data.get("tool", {}).get("uv", {}).get("sources", {})
+
+        for source_config in sources.values():
+            if isinstance(source_config, dict):
+                index = source_config.get("index")
+                if index:
+                    index_env = build_env_with_tool_repository_credentials(index)
+                    env.update(index_env)
+    except Exception:  # noqa: S110
+        pass
+
+    try:
+        subprocess.run(command, capture_output=False, text=True, check=True, env=env)  # noqa: S603
 
     except subprocess.CalledProcessError as e:
         handle_error(e, crew_type)

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

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

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

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

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

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

src/crewai/events/listeners/tracing/trace_listener.py

@@ -32,6 +32,13 @@ from crewai.events.types.flow_events import (
     MethodExecutionFinishedEvent,
     MethodExecutionStartedEvent,
 )
+from crewai.events.types.knowledge_events import (
+    KnowledgeQueryCompletedEvent,
+    KnowledgeQueryFailedEvent,
+    KnowledgeQueryStartedEvent,
+    KnowledgeRetrievalCompletedEvent,
+    KnowledgeRetrievalStartedEvent,
+)
 from crewai.events.types.llm_events import (
     LLMCallCompletedEvent,
     LLMCallFailedEvent,
@@ -310,6 +317,26 @@ class TraceCollectionListener(BaseEventListener):
         def on_agent_reasoning_failed(source, event):
             self._handle_action_event("agent_reasoning_failed", source, event)
 
+        @event_bus.on(KnowledgeRetrievalStartedEvent)
+        def on_knowledge_retrieval_started(source, event):
+            self._handle_action_event("knowledge_retrieval_started", source, event)
+
+        @event_bus.on(KnowledgeRetrievalCompletedEvent)
+        def on_knowledge_retrieval_completed(source, event):
+            self._handle_action_event("knowledge_retrieval_completed", source, event)
+
+        @event_bus.on(KnowledgeQueryStartedEvent)
+        def on_knowledge_query_started(source, event):
+            self._handle_action_event("knowledge_query_started", source, event)
+
+        @event_bus.on(KnowledgeQueryCompletedEvent)
+        def on_knowledge_query_completed(source, event):
+            self._handle_action_event("knowledge_query_completed", source, event)
+
+        @event_bus.on(KnowledgeQueryFailedEvent)
+        def on_knowledge_query_failed(source, event):
+            self._handle_action_event("knowledge_query_failed", source, event)
+
     def _initialize_crew_batch(self, source: Any, event: Any):
         """Initialize trace batch"""
         user_context = self._get_user_context()

src/crewai/events/types/knowledge_events.py

@@ -1,51 +1,60 @@
-from crewai.agents.agent_builder.base_agent import BaseAgent
+from typing import Any
+
 from crewai.events.base_events import BaseEvent
 
 
-class KnowledgeRetrievalStartedEvent(BaseEvent):
+class KnowledgeEventBase(BaseEvent):
+    task_id: str | None = None
+    task_name: str | None = None
+    from_task: Any | None = None
+    from_agent: Any | None = None
+    agent_role: str | None = None
+    agent_id: str | None = None
+
+    def __init__(self, **data):
+        super().__init__(**data)
+        self._set_agent_params(data)
+        self._set_task_params(data)
+
+
+class KnowledgeRetrievalStartedEvent(KnowledgeEventBase):
     """Event emitted when a knowledge retrieval is started."""
 
     type: str = "knowledge_search_query_started"
-    agent: BaseAgent
 
 
-class KnowledgeRetrievalCompletedEvent(BaseEvent):
+class KnowledgeRetrievalCompletedEvent(KnowledgeEventBase):
     """Event emitted when a knowledge retrieval is completed."""
 
     query: str
     type: str = "knowledge_search_query_completed"
-    agent: BaseAgent
     retrieved_knowledge: str
 
 
-class KnowledgeQueryStartedEvent(BaseEvent):
+class KnowledgeQueryStartedEvent(KnowledgeEventBase):
     """Event emitted when a knowledge query is started."""
 
     task_prompt: str
     type: str = "knowledge_query_started"
-    agent: BaseAgent
 
 
-class KnowledgeQueryFailedEvent(BaseEvent):
+class KnowledgeQueryFailedEvent(KnowledgeEventBase):
     """Event emitted when a knowledge query fails."""
 
     type: str = "knowledge_query_failed"
-    agent: BaseAgent
     error: str
 
 
-class KnowledgeQueryCompletedEvent(BaseEvent):
+class KnowledgeQueryCompletedEvent(KnowledgeEventBase):
     """Event emitted when a knowledge query is completed."""
 
     query: str
     type: str = "knowledge_query_completed"
-    agent: BaseAgent
 
 
-class KnowledgeSearchQueryFailedEvent(BaseEvent):
+class KnowledgeSearchQueryFailedEvent(KnowledgeEventBase):
     """Event emitted when a knowledge search query fails."""
 
     query: str
     type: str = "knowledge_search_query_failed"
-    agent: BaseAgent
     error: str

src/crewai/events/types/llm_guardrail_events.py

@@ -5,7 +5,21 @@ from typing import Any
 from crewai.events.base_events import BaseEvent
 
 
-class LLMGuardrailStartedEvent(BaseEvent):
+class LLMGuardrailBaseEvent(BaseEvent):
+    task_id: str | None = None
+    task_name: str | None = None
+    from_task: Any | None = None
+    from_agent: Any | None = None
+    agent_role: str | None = None
+    agent_id: str | None = None
+
+    def __init__(self, **data):
+        super().__init__(**data)
+        self._set_agent_params(data)
+        self._set_task_params(data)
+
+
+class LLMGuardrailStartedEvent(LLMGuardrailBaseEvent):
     """Event emitted when a guardrail task starts
 
     Attributes:
@@ -29,7 +43,7 @@ class LLMGuardrailStartedEvent(BaseEvent):
             self.guardrail = getsource(self.guardrail).strip()
 
 
-class LLMGuardrailCompletedEvent(BaseEvent):
+class LLMGuardrailCompletedEvent(LLMGuardrailBaseEvent):
     """Event emitted when a guardrail task completes
 
     Attributes:
@@ -44,3 +58,16 @@ class LLMGuardrailCompletedEvent(BaseEvent):
     result: Any
     error: str | None = None
     retry_count: int
+
+
+class LLMGuardrailFailedEvent(LLMGuardrailBaseEvent):
+    """Event emitted when a guardrail task fails
+
+    Attributes:
+        error: The error message
+        retry_count: The number of times the guardrail has been retried
+    """
+
+    type: str = "llm_guardrail_failed"
+    error: str
+    retry_count: int

src/crewai/events/utils/console_formatter.py

@@ -1377,7 +1377,7 @@ class ConsoleFormatter:
         if isinstance(formatted_answer, AgentAction):
             thought = re.sub(r"\n+", "\n", formatted_answer.thought)
             formatted_json = json.dumps(
-                formatted_answer.tool_input,
+                json.loads(formatted_answer.tool_input),
                 indent=2,
                 ensure_ascii=False,
             )

src/crewai/lite_agent.py

@@ -4,6 +4,7 @@ import uuid
 from collections.abc import Callable
 from typing import (
     Any,
+    Literal,
     cast,
     get_args,
     get_origin,
@@ -62,6 +63,7 @@ from crewai.utilities.llm_utils import create_llm
 from crewai.utilities.printer import Printer
 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
 
 
 class LiteAgentOutput(BaseModel):
@@ -180,7 +182,7 @@ class LiteAgent(FlowTrackable, BaseModel):
     _token_process: TokenProcess = PrivateAttr(default_factory=TokenProcess)
     _cache_handler: CacheHandler = PrivateAttr(default_factory=CacheHandler)
     _key: str = PrivateAttr(default_factory=lambda: str(uuid.uuid4()))
-    _messages: list[dict[str, str]] = PrivateAttr(default_factory=list)
+    _messages: list[LLMMessage] = PrivateAttr(default_factory=list)
     _iterations: int = PrivateAttr(default=0)
     _printer: Printer = PrivateAttr(default_factory=Printer)
     _guardrail: Callable | None = PrivateAttr(default=None)
@@ -219,7 +221,6 @@ class LiteAgent(FlowTrackable, BaseModel):
                 raise TypeError(
                     f"Guardrail requires LLM instance of type BaseLLM, got {type(self.llm).__name__}"
                 )
-
             self._guardrail = LLMGuardrail(description=self.guardrail, llm=self.llm)
 
         return self
@@ -276,7 +277,7 @@ class LiteAgent(FlowTrackable, BaseModel):
         """Return the original role for compatibility with tool interfaces."""
         return self.role
 
-    def kickoff(self, messages: str | list[dict[str, str]]) -> LiteAgentOutput:
+    def kickoff(self, messages: str | list[LLMMessage]) -> LiteAgentOutput:
         """
         Execute the agent with the given messages.
 
@@ -368,6 +369,7 @@ class LiteAgent(FlowTrackable, BaseModel):
                 guardrail=self._guardrail,
                 retry_count=self._guardrail_retry_count,
                 event_source=self,
+                from_agent=self,
             )
 
             if not guardrail_result.success:
@@ -414,9 +416,7 @@ class LiteAgent(FlowTrackable, BaseModel):
 
         return output
 
-    async def kickoff_async(
-        self, messages: str | list[dict[str, str]]
-    ) -> LiteAgentOutput:
+    async def kickoff_async(self, messages: str | list[LLMMessage]) -> LiteAgentOutput:
         """
         Execute the agent asynchronously with the given messages.
 
@@ -461,9 +461,7 @@ class LiteAgent(FlowTrackable, BaseModel):
 
         return base_prompt
 
-    def _format_messages(
-        self, messages: str | list[dict[str, str]]
-    ) -> list[dict[str, str]]:
+    def _format_messages(self, messages: str | list[LLMMessage]) -> list[LLMMessage]:
         """Format messages for the LLM."""
         if isinstance(messages, str):
             messages = [{"role": "user", "content": messages}]
@@ -471,7 +469,9 @@ class LiteAgent(FlowTrackable, BaseModel):
         system_prompt = self._get_default_system_prompt()
 
         # Add system message at the beginning
-        formatted_messages = [{"role": "system", "content": system_prompt}]
+        formatted_messages: list[LLMMessage] = [
+            {"role": "system", "content": system_prompt}
+        ]
 
         # Add the rest of the messages
         formatted_messages.extend(messages)
@@ -583,6 +583,8 @@ class LiteAgent(FlowTrackable, BaseModel):
             ),
         )
 
-    def _append_message(self, text: str, role: str = "assistant") -> None:
+    def _append_message(
+        self, text: str, role: Literal["user", "assistant", "system"] = "assistant"
+    ) -> None:
         """Append a message to the message list with the given role."""
-        self._messages.append(format_message_for_llm(text, role=role))
+        self._messages.append(cast(LLMMessage, format_message_for_llm(text, role=role)))

src/crewai/task.py

@@ -462,6 +462,8 @@ class Task(BaseModel):
                     guardrail=self._guardrail,
                     retry_count=self.retry_count,
                     event_source=self,
+                    from_task=self,
+                    from_agent=agent,
                 )
                 if not guardrail_result.success:
                     if self.retry_count >= self.guardrail_max_retries:

src/crewai/tools/tool_usage.py

@@ -1,6 +1,6 @@
-import ast
 import datetime
 import json
+import re
 import time
 from difflib import SequenceMatcher
 from json import JSONDecodeError
@@ -44,6 +44,183 @@ OPENAI_BIGGER_MODELS = [
 ]
 
 
+def _safe_literal_parse(input_str: str) -> Any:
+    """
+    Safely parse a limited subset of Python literal syntax without using ast.literal_eval.
+    Only supports: strings (single/double quotes), numbers, booleans, None, lists, dicts.
+    Rejects any input that could lead to code execution.
+    
+    Args:
+        input_str: String to parse
+        
+    Returns:
+        Parsed Python object
+        
+    Raises:
+        ValueError: If input contains unsafe or unsupported syntax
+    """
+    if not isinstance(input_str, str):
+        raise ValueError("Input must be a string")
+    
+    stripped = input_str.strip()
+    if not stripped:
+        raise ValueError("Input cannot be empty")
+    
+    # Check for potentially dangerous patterns
+    dangerous_patterns = [
+        r'__.*__',  # dunder methods
+        r'import\b',  # import statements
+        r'exec\b',  # exec function
+        r'eval\b',  # eval function
+        r'lambda\b',  # lambda functions
+        r'def\b',  # function definitions
+        r'class\b',  # class definitions
+        r'@\w+',  # decorators
+        r'\.\.\.',  # ellipsis (could be used in slicing)
+        r'->[^\]]*\]',  # type hints in lists
+    ]
+    
+    for pattern in dangerous_patterns:
+        if re.search(pattern, stripped, re.IGNORECASE):
+            raise ValueError(f"Potentially dangerous pattern detected: {pattern}")
+    
+    # Only allow specific characters
+    allowed_chars = r'[\s\w\.\-\+\*/\(\)\[\]\{\}:\'"<>!=,!=\?%&|~^`]'
+    if not re.fullmatch(f'{allowed_chars}*', stripped):
+        raise ValueError("Input contains unsupported characters")
+    
+    # Try JSON parsing first (safest)
+    try:
+        return json.loads(stripped)
+    except (json.JSONDecodeError, TypeError):
+        pass
+    
+    # Manual parsing for simple Python literals (JSON with single quotes, etc.)
+    try:
+        return _parse_python_literal_safe(stripped)
+    except Exception as e:
+        raise ValueError(f"Failed to parse input safely: {e}")
+
+
+def _parse_python_literal_safe(input_str: str) -> Any:
+    """
+    Parse a limited subset of Python literals safely.
+    
+    Args:
+        input_str: String to parse
+        
+    Returns:
+        Parsed Python object
+    """
+    # Handle None
+    if input_str == 'None':
+        return None
+    
+    # Handle booleans
+    if input_str == 'True':
+        return True
+    if input_str == 'False':
+        return False
+    
+    # Handle numbers
+    if re.fullmatch(r'-?\d+$', input_str):
+        return int(input_str)
+    if re.fullmatch(r'-?\d+\.\d+$', input_str):
+        return float(input_str)
+    
+    # Handle strings with single quotes (convert to JSON format)
+    if (input_str.startswith("'") and input_str.endswith("'")) or \
+       (input_str.startswith('"') and input_str.endswith('"')):
+        # Simple string - just remove quotes and escape common sequences
+        inner = input_str[1:-1]
+        # Handle common escape sequences safely
+        inner = inner.replace("\\'", "'").replace('\\"', '"').replace("\\\\", "\\")
+        return inner
+    
+    # Handle lists
+    if input_str.startswith('[') and input_str.endswith(']'):
+        inner = input_str[1:-1].strip()
+        if not inner:
+            return []
+        
+        items = _split_items_safe(inner)
+        return [_parse_python_literal_safe(item.strip()) for item in items]
+    
+    # Handle dictionaries
+    if input_str.startswith('{') and input_str.endswith('}'):
+        inner = input_str[1:-1].strip()
+        if not inner:
+            return {}
+        
+        pairs = _split_items_safe(inner)
+        result = {}
+        for pair in pairs:
+            if ':' not in pair:
+                raise ValueError(f"Invalid dict pair: {pair}")
+            
+            key_str, value_str = pair.split(':', 1)
+            key = _parse_python_literal_safe(key_str.strip())
+            value = _parse_python_literal_safe(value_str.strip())
+            if not isinstance(key, str):
+                raise ValueError(f"Dict keys must be strings, got {type(key)}")
+            result[key] = value
+        
+        return result
+    
+    raise ValueError(f"Unsupported literal format: {input_str}")
+
+
+def _split_items_safe(input_str: str, delimiter: str = ',') -> list[str]:
+    """
+    Split a list or dict string into items, respecting nested structures.
+    
+    Args:
+        input_str: String to split
+        delimiter: Delimiter to split on
+        
+    Returns:
+        List of item strings
+    """
+    items = []
+    current = []
+    depth = 0
+    in_string = False
+    string_char = None
+    i = 0
+    
+    while i < len(input_str):
+        char = input_str[i]
+        
+        # Handle string literals
+        if char in ('"', "'") and (i == 0 or input_str[i-1] != '\\'):
+            if not in_string:
+                in_string = True
+                string_char = char
+            elif char == string_char:
+                in_string = False
+                string_char = None
+        
+        # Track nesting depth when not in strings
+        elif not in_string:
+            if char in ('[', '(', '{'):
+                depth += 1
+            elif char in (']', ')', '}'):
+                depth -= 1
+            elif char == delimiter and depth == 0:
+                items.append(''.join(current).strip())
+                current = []
+                i += 1
+                continue
+        
+        current.append(char)
+        i += 1
+    
+    if current:
+        items.append(''.join(current).strip())
+    
+    return items
+
+
 class ToolUsageError(Exception):
     """Exception raised for errors in the tool usage."""
 
@@ -524,14 +701,14 @@ class ToolUsage:
         except (JSONDecodeError, TypeError):
             pass  # Continue to the next parsing attempt
 
-        # Attempt 2: Parse as Python literal
+        # Attempt 2: Parse as Python literal (safe alternative to ast.literal_eval)
         try:
-            arguments = ast.literal_eval(tool_input)
+            arguments = _safe_literal_parse(tool_input)
             if isinstance(arguments, dict):
                 return arguments
-        except (ValueError, SyntaxError):
-            repaired_input = repair_json(tool_input)
+        except ValueError:
             # Continue to the next parsing attempt
+            pass
 
         # Attempt 3: Parse as JSON5
         try:

src/crewai/utilities/agent_utils.py

@@ -31,6 +31,7 @@ from crewai.utilities.types import LLMMessage
 
 if TYPE_CHECKING:
     from crewai.agent import Agent
+    from crewai.lite_agent import LiteAgent
     from crewai.task import Task
 
 
@@ -222,7 +223,7 @@ def get_llm_response(
     callbacks: list[Callable[..., Any]],
     printer: Printer,
     from_task: Task | None = None,
-    from_agent: Agent | None = None,
+    from_agent: Agent | LiteAgent | None = None,
 ) -> str:
     """Call the LLM and return the response, handling any invalid responses.
 

src/crewai/utilities/converter.py

@@ -14,6 +14,7 @@ from crewai.utilities.pydantic_schema_parser import PydanticSchemaParser
 
 if TYPE_CHECKING:
     from crewai.agent import Agent
+    from crewai.agents.agent_builder.base_agent import BaseAgent
     from crewai.llm import LLM
     from crewai.llms.base_llm import BaseLLM
 
@@ -143,7 +144,7 @@ def convert_to_model(
     result: str,
     output_pydantic: type[BaseModel] | None,
     output_json: type[BaseModel] | None,
-    agent: Agent | None = None,
+    agent: Agent | BaseAgent | None = None,
     converter_cls: type[Converter] | None = None,
 ) -> dict[str, Any] | BaseModel | str:
     """Convert a result string to a Pydantic model or JSON.
@@ -215,7 +216,7 @@ def handle_partial_json(
     result: str,
     model: type[BaseModel],
     is_json_output: bool,
-    agent: Agent | None,
+    agent: Agent | BaseAgent | None,
     converter_cls: type[Converter] | None = None,
 ) -> dict[str, Any] | BaseModel | str:
     """Handle partial JSON in a result string and convert to Pydantic model or dict.
@@ -260,7 +261,7 @@ def convert_with_instructions(
     result: str,
     model: type[BaseModel],
     is_json_output: bool,
-    agent: Agent | None,
+    agent: Agent | BaseAgent | None,
     converter_cls: type[Converter] | None = None,
 ) -> dict | BaseModel | str:
     """Convert a result string to a Pydantic model or JSON using instructions.
@@ -283,7 +284,12 @@ def convert_with_instructions(
     """
     if agent is None:
         raise TypeError("Agent must be provided if converter_cls is not specified.")
-    llm = agent.function_calling_llm or agent.llm
+
+    llm = getattr(agent, "function_calling_llm", None) or agent.llm
+
+    if llm is None:
+        raise ValueError("Agent must have a valid LLM instance for conversion")
+
     instructions = get_conversion_instructions(model=model, llm=llm)
     converter = create_converter(
         agent=agent,
@@ -299,7 +305,7 @@ def convert_with_instructions(
 
     if isinstance(exported_result, ConverterError):
         Printer().print(
-            content=f"{exported_result.message} Using raw output instead.",
+            content=f"Failed to convert result to model: {exported_result}",
             color="red",
         )
         return result
@@ -308,7 +314,7 @@ def convert_with_instructions(
 
 
 def get_conversion_instructions(
-    model: type[BaseModel], llm: BaseLLM | LLM | str
+    model: type[BaseModel], llm: BaseLLM | LLM | str | Any
 ) -> str:
     """Generate conversion instructions based on the model and LLM capabilities.
 
@@ -357,7 +363,7 @@ class CreateConverterKwargs(TypedDict, total=False):
 
 
 def create_converter(
-    agent: Agent | None = None,
+    agent: Agent | BaseAgent | None = None,
     converter_cls: type[Converter] | None = None,
     *args: Any,
     **kwargs: Unpack[CreateConverterKwargs],