ci: trigger test matrix

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

.github/dependabot.yml

@@ -0,0 +1,11 @@
+# To get started with Dependabot version updates, you'll need to specify which 
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
+
+version: 2
+updates:
+  - package-ecosystem: uv # See documentation for possible values
+    directory: "/" # Location of package manifests
+    schedule:
+      interval: "weekly"

docs/en/concepts/tasks.mdx

@@ -60,6 +60,7 @@ crew = Crew(
 | **Output Pydantic** _(optional)_ | `output_pydantic` | `Optional[Type[BaseModel]]`   | A Pydantic model for task output.                                                                                    |
 | **Callback** _(optional)_        | `callback`        | `Optional[Any]`               | Function/object to be executed after task completion.                                                                |
 | **Guardrail** _(optional)_       | `guardrail`       | `Optional[Callable]`             | Function to validate task output before proceeding to next task.                                                  |
+| **Guardrails** _(optional)_       | `guardrails`       | `Optional[List[Callable] | List[str]]` | List of guardrails to validate task output before proceeding to next task.                                      |
 | **Guardrail Max Retries** _(optional)_ | `guardrail_max_retries` | `Optional[int]`     | Maximum number of retries when guardrail validation fails. Defaults to 3.                                         |
 
 <Note type="warning" title="Deprecated: max_retries">
@@ -223,6 +224,7 @@ By default, the `TaskOutput` will only include the `raw` output. A `TaskOutput`
 | **JSON Dict**     | `json_dict`     | `Optional[Dict[str, Any]]` | A dictionary representing the JSON output of the task.                                             |
 | **Agent**         | `agent`         | `str`                      | The agent that executed the task.                                                                  |
 | **Output Format** | `output_format` | `OutputFormat`             | The format of the task output, with options including RAW, JSON, and Pydantic. The default is RAW. |
+| **Messages**      | `messages`      | `list[LLMMessage]`         | The messages from the last task execution.                                                           |
 
 ### Task Methods and Properties
 
@@ -341,7 +343,11 @@ Task guardrails provide a way to validate and transform task outputs before they
 are passed to the next task. This feature helps ensure data quality and provides
 feedback to agents when their output doesn't meet specific criteria.
 
-Guardrails are implemented as Python functions that contain custom validation logic, giving you complete control over the validation process and ensuring reliable, deterministic results.
+CrewAI supports two types of guardrails:
+
+1. **Function-based guardrails**: Python functions with custom validation logic, giving you complete control over the validation process and ensuring reliable, deterministic results.
+
+2. **LLM-based guardrails**: String descriptions that use the agent's LLM to validate outputs based on natural language criteria. These are ideal for complex or subjective validation requirements.
 
 ### Function-Based Guardrails
 
@@ -355,12 +361,12 @@ def validate_blog_content(result: TaskOutput) -> Tuple[bool, Any]:
     """Validate blog content meets requirements."""
     try:
         # Check word count
-        word_count = len(result.split())
+        word_count = len(result.raw.split())
         if word_count > 200:
             return (False, "Blog content exceeds 200 words")
 
         # Additional validation logic here
-        return (True, result.strip())
+        return (True, result.raw.strip())
     except Exception as e:
         return (False, "Unexpected error during validation")
 
@@ -372,6 +378,147 @@ blog_task = Task(
 )
 ```
 
+### LLM-Based Guardrails (String Descriptions)
+
+Instead of writing custom validation functions, you can use string descriptions that leverage LLM-based validation. When you provide a string to the `guardrail` or `guardrails` parameter, CrewAI automatically creates an `LLMGuardrail` that uses the agent's LLM to validate the output based on your description.
+
+**Requirements**:
+- The task must have an `agent` assigned (the guardrail uses the agent's LLM)
+- Provide a clear, descriptive string explaining the validation criteria
+
+```python Code
+from crewai import Task
+
+# Single LLM-based guardrail
+blog_task = Task(
+    description="Write a blog post about AI",
+    expected_output="A blog post under 200 words",
+    agent=blog_agent,
+    guardrail="The blog post must be under 200 words and contain no technical jargon"
+)
+```
+
+LLM-based guardrails are particularly useful for:
+- **Complex validation logic** that's difficult to express programmatically
+- **Subjective criteria** like tone, style, or quality assessments
+- **Natural language requirements** that are easier to describe than code
+
+The LLM guardrail will:
+1. Analyze the task output against your description
+2. Return `(True, output)` if the output complies with the criteria
+3. Return `(False, feedback)` with specific feedback if validation fails
+
+**Example with detailed validation criteria**:
+
+```python Code
+research_task = Task(
+    description="Research the latest developments in quantum computing",
+    expected_output="A comprehensive research report",
+    agent=researcher_agent,
+    guardrail="""
+    The research report must:
+    - Be at least 1000 words long
+    - Include at least 5 credible sources
+    - Cover both technical and practical applications
+    - Be written in a professional, academic tone
+    - Avoid speculation or unverified claims
+    """
+)
+```
+
+### Multiple Guardrails
+
+You can apply multiple guardrails to a task using the `guardrails` parameter. Multiple guardrails are executed sequentially, with each guardrail receiving the output from the previous one. This allows you to chain validation and transformation steps.
+
+The `guardrails` parameter accepts:
+- A list of guardrail functions or string descriptions
+- A single guardrail function or string (same as `guardrail`)
+
+**Note**: If `guardrails` is provided, it takes precedence over `guardrail`. The `guardrail` parameter will be ignored when `guardrails` is set.
+
+```python Code
+from typing import Tuple, Any
+from crewai import TaskOutput, Task
+
+def validate_word_count(result: TaskOutput) -> Tuple[bool, Any]:
+    """Validate word count is within limits."""
+    word_count = len(result.raw.split())
+    if word_count < 100:
+        return (False, f"Content too short: {word_count} words. Need at least 100 words.")
+    if word_count > 500:
+        return (False, f"Content too long: {word_count} words. Maximum is 500 words.")
+    return (True, result.raw)
+
+def validate_no_profanity(result: TaskOutput) -> Tuple[bool, Any]:
+    """Check for inappropriate language."""
+    profanity_words = ["badword1", "badword2"]  # Example list
+    content_lower = result.raw.lower()
+    for word in profanity_words:
+        if word in content_lower:
+            return (False, f"Inappropriate language detected: {word}")
+    return (True, result.raw)
+
+def format_output(result: TaskOutput) -> Tuple[bool, Any]:
+    """Format and clean the output."""
+    formatted = result.raw.strip()
+    # Capitalize first letter
+    formatted = formatted[0].upper() + formatted[1:] if formatted else formatted
+    return (True, formatted)
+
+# Apply multiple guardrails sequentially
+blog_task = Task(
+    description="Write a blog post about AI",
+    expected_output="A well-formatted blog post between 100-500 words",
+    agent=blog_agent,
+    guardrails=[
+        validate_word_count,      # First: validate length
+        validate_no_profanity,    # Second: check content
+        format_output             # Third: format the result
+    ],
+    guardrail_max_retries=3
+)
+```
+
+In this example, the guardrails execute in order:
+1. `validate_word_count` checks the word count
+2. `validate_no_profanity` checks for inappropriate language (using the output from step 1)
+3. `format_output` formats the final result (using the output from step 2)
+
+If any guardrail fails, the error is sent back to the agent, and the task is retried up to `guardrail_max_retries` times.
+
+**Mixing function-based and LLM-based guardrails**:
+
+You can combine both function-based and string-based guardrails in the same list:
+
+```python Code
+from typing import Tuple, Any
+from crewai import TaskOutput, Task
+
+def validate_word_count(result: TaskOutput) -> Tuple[bool, Any]:
+    """Validate word count is within limits."""
+    word_count = len(result.raw.split())
+    if word_count < 100:
+        return (False, f"Content too short: {word_count} words. Need at least 100 words.")
+    if word_count > 500:
+        return (False, f"Content too long: {word_count} words. Maximum is 500 words.")
+    return (True, result.raw)
+
+# Mix function-based and LLM-based guardrails
+blog_task = Task(
+    description="Write a blog post about AI",
+    expected_output="A well-formatted blog post between 100-500 words",
+    agent=blog_agent,
+    guardrails=[
+        validate_word_count,  # Function-based: precise word count check
+        "The content must be engaging and suitable for a general audience",  # LLM-based: subjective quality check
+        "The writing style should be clear, concise, and free of technical jargon"  # LLM-based: style validation
+    ],
+    guardrail_max_retries=3
+)
+```
+
+This approach combines the precision of programmatic validation with the flexibility of LLM-based assessment for subjective criteria.
+
 ### Guardrail Function Requirements
 
 1. **Function Signature**:

lib/crewai-tools/src/crewai_tools/tools/qdrant_vector_search_tool/qdrant_search_tool.py

@@ -12,12 +12,16 @@ from pydantic.types import ImportString
 
 
 class QdrantToolSchema(BaseModel):
-    query: str = Field(..., description="Query to search in Qdrant DB")
+    query: str = Field(
+        ..., description="Query to search in Qdrant DB - always required."
+    )
     filter_by: str | None = Field(
-        default=None, description="Parameter to filter the search by."
+        default=None,
+        description="Parameter to filter the search by. When filtering, needs to be used in conjunction with filter_value.",
     )
     filter_value: Any | None = Field(
-        default=None, description="Value to filter the search by."
+        default=None,
+        description="Value to filter the search by. When filtering, needs to be used in conjunction with filter_by.",
     )
 
 

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

@@ -753,3 +753,99 @@ def get_a2a_agents_and_response_model(
     """
     a2a_agents, agent_ids = extract_a2a_agent_ids_from_config(a2a_config=a2a_config)
     return a2a_agents, create_agent_response_model(agent_ids)
+
+
+def extract_agent_identifiers_from_cards(
+    a2a_agents: list[A2AConfig],
+    agent_cards: dict[str, AgentCard],
+) -> tuple[str, ...]:
+    """Extract all valid agent identifiers (endpoints and skill IDs) from agent cards.
+
+    Args:
+        a2a_agents: List of A2A agent configurations
+        agent_cards: Dictionary mapping endpoints to AgentCards
+
+    Returns:
+        Tuple of all valid identifiers (endpoints + skill IDs)
+    """
+    identifiers = set()
+
+    for config in a2a_agents:
+        identifiers.add(config.endpoint)
+
+    for card in agent_cards.values():
+        if card.skills:
+            for skill in card.skills:
+                identifiers.add(skill.id)
+
+    return tuple(sorted(identifiers))
+
+
+def resolve_agent_identifier(
+    identifier: str,
+    a2a_agents: list[A2AConfig],
+    agent_cards: dict[str, AgentCard],
+) -> str:
+    """Resolve an agent identifier (endpoint or skill ID) to a canonical endpoint.
+
+    This function allows both endpoint URLs and skill IDs to be used as agent identifiers.
+    If the identifier is already an endpoint, it's returned as-is. If it's a skill ID,
+    it's resolved to the endpoint of the agent card that contains that skill.
+
+    Args:
+        identifier: Either an endpoint URL or a skill ID
+        a2a_agents: List of A2A agent configurations
+        agent_cards: Dictionary mapping endpoints to AgentCards
+
+    Returns:
+        The canonical endpoint URL
+
+    Raises:
+        ValueError: If the identifier is unknown or ambiguous (matches multiple agents)
+
+    Examples:
+        >>> # Endpoint passthrough
+        >>> resolve_agent_identifier(
+        ...     "http://localhost:10001/.well-known/agent-card.json",
+        ...     a2a_agents,
+        ...     agent_cards
+        ... )
+        'http://localhost:10001/.well-known/agent-card.json'
+
+        >>> # Skill ID resolution
+        >>> resolve_agent_identifier("Research", a2a_agents, agent_cards)
+        'http://localhost:10001/.well-known/agent-card.json'
+    """
+    endpoints = {config.endpoint for config in a2a_agents}
+    if identifier in endpoints:
+        return identifier
+
+    matching_endpoints: list[str] = []
+    for endpoint, card in agent_cards.items():
+        if card.skills:
+            for skill in card.skills:
+                if skill.id == identifier:
+                    matching_endpoints.append(endpoint)
+                    break
+
+    if len(matching_endpoints) == 0:
+        available_endpoints = ", ".join(sorted(endpoints))
+        available_skill_ids = []
+        for card in agent_cards.values():
+            if card.skills:
+                available_skill_ids.extend([skill.id for skill in card.skills])
+        available_skills = ", ".join(sorted(set(available_skill_ids))) if available_skill_ids else "none"
+        raise ValueError(
+            f"Unknown A2A agent identifier '{identifier}'. "
+            f"Available endpoints: {available_endpoints}. "
+            f"Available skill IDs: {available_skills}."
+        )
+
+    if len(matching_endpoints) > 1:
+        endpoints_list = ", ".join(sorted(matching_endpoints))
+        raise ValueError(
+            f"Ambiguous skill ID '{identifier}' found in multiple agents: {endpoints_list}. "
+            f"Please use the specific endpoint URL to disambiguate."
+        )
+
+    return matching_endpoints[0]

lib/crewai/src/crewai/a2a/wrapper.py

@@ -23,9 +23,12 @@ from crewai.a2a.templates import (
 )
 from crewai.a2a.types import AgentResponseProtocol
 from crewai.a2a.utils import (
+    create_agent_response_model,
     execute_a2a_delegation,
+    extract_agent_identifiers_from_cards,
     fetch_agent_card,
     get_a2a_agents_and_response_model,
+    resolve_agent_identifier,
 )
 from crewai.events.event_bus import crewai_event_bus
 from crewai.events.types.a2a_events import (
@@ -190,6 +193,9 @@ def _execute_task_with_a2a(
         finally:
             task.description = original_description
 
+    agent_identifiers = extract_agent_identifiers_from_cards(a2a_agents, agent_cards)
+    agent_response_model = create_agent_response_model(agent_identifiers)
+
     task.description = _augment_prompt_with_a2a(
         a2a_agents=a2a_agents,
         task_description=original_description,
@@ -301,6 +307,13 @@ def _augment_prompt_with_a2a(
 IMPORTANT: You have the ability to delegate this task to remote A2A agents.
 
 {agents_text}
+
+AGENT IDENTIFICATION: When setting a2a_ids, you may use either:
+1. The agent's endpoint URL (e.g., "http://localhost:10001/.well-known/agent-card.json")
+2. The exact skill.id from the agent's skills list (e.g., "Research")
+
+Prefer using endpoint URLs when possible to avoid ambiguity. If a skill.id appears on multiple agents, you MUST use the endpoint URL to specify which agent you want.
+
 {history_text}{turn_info}
 
 
@@ -373,6 +386,9 @@ def _handle_agent_response_and_continue(
     if "agent_card" in a2a_result and agent_id not in agent_cards_dict:
         agent_cards_dict[agent_id] = a2a_result["agent_card"]
 
+    agent_identifiers = extract_agent_identifiers_from_cards(a2a_agents, agent_cards_dict)
+    agent_response_model = create_agent_response_model(agent_identifiers)
+
     task.description = _augment_prompt_with_a2a(
         a2a_agents=a2a_agents,
         task_description=original_task_description,
@@ -445,16 +461,20 @@ def _delegate_to_a2a(
         ImportError: If a2a-sdk is not installed
     """
     a2a_agents, agent_response_model = get_a2a_agents_and_response_model(self.a2a)
-    agent_ids = tuple(config.endpoint for config in a2a_agents)
     current_request = str(agent_response.message)
-    agent_id = agent_response.a2a_ids[0]
+    agent_identifier = agent_response.a2a_ids[0]
 
-    if agent_id not in agent_ids:
-        raise ValueError(
-            f"Unknown A2A agent ID(s): {agent_response.a2a_ids} not in {agent_ids}"
+    agent_cards_dict = agent_cards or {}
+    try:
+        agent_endpoint = resolve_agent_identifier(
+            agent_identifier, a2a_agents, agent_cards_dict
         )
+    except ValueError as e:
+        raise ValueError(
+            f"Failed to resolve A2A agent identifier '{agent_identifier}': {e}"
+        ) from e
 
-    agent_config = next(filter(lambda x: x.endpoint == agent_id, a2a_agents))
+    agent_config = next(filter(lambda x: x.endpoint == agent_endpoint, a2a_agents))
     task_config = task.config or {}
     context_id = task_config.get("context_id")
     task_id_config = task_config.get("task_id")
@@ -488,7 +508,7 @@ def _delegate_to_a2a(
                 metadata=metadata,
                 extensions=extensions,
                 conversation_history=conversation_history,
-                agent_id=agent_id,
+                agent_id=agent_endpoint,
                 agent_role=Role.user,
                 agent_branch=agent_branch,
                 response_model=agent_config.response_model,
@@ -501,7 +521,7 @@ def _delegate_to_a2a(
                 final_result, next_request = _handle_agent_response_and_continue(
                     self=self,
                     a2a_result=a2a_result,
-                    agent_id=agent_id,
+                    agent_id=agent_endpoint,
                     agent_cards=agent_cards,
                     a2a_agents=a2a_agents,
                     original_task_description=original_task_description,

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

@@ -119,6 +119,7 @@ class Agent(BaseAgent):
 
     _times_executed: int = PrivateAttr(default=0)
     _mcp_clients: list[Any] = PrivateAttr(default_factory=list)
+    _last_messages: list[LLMMessage] = PrivateAttr(default_factory=list)
     max_execution_time: int | None = Field(
         default=None,
         description="Maximum execution time for an agent to execute a task",
@@ -538,6 +539,12 @@ class Agent(BaseAgent):
             event=AgentExecutionCompletedEvent(agent=self, task=task, output=result),
         )
 
+        self._last_messages = (
+            self.agent_executor.messages.copy()
+            if self.agent_executor and hasattr(self.agent_executor, "messages")
+            else []
+        )
+
         self._cleanup_mcp_clients()
 
         return result
@@ -1341,6 +1348,15 @@ class Agent(BaseAgent):
     def set_fingerprint(self, fingerprint: Fingerprint) -> None:
         self.security_config.fingerprint = fingerprint
 
+    @property
+    def last_messages(self) -> list[LLMMessage]:
+        """Get messages from the last task execution.
+
+        Returns:
+            List of LLM messages from the most recent task execution.
+        """
+        return self._last_messages
+
     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(

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

@@ -38,6 +38,10 @@ from crewai.utilities.agent_utils import (
 )
 from crewai.utilities.constants import TRAINING_DATA_FILE
 from crewai.utilities.i18n import I18N, get_i18n
+from crewai.utilities.llm_call_hooks import (
+    get_after_llm_call_hooks,
+    get_before_llm_call_hooks,
+)
 from crewai.utilities.printer import Printer
 from crewai.utilities.tool_utils import execute_tool_and_check_finality
 from crewai.utilities.training_handler import CrewTrainingHandler
@@ -130,6 +134,10 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
         self.messages: list[LLMMessage] = []
         self.iterations = 0
         self.log_error_after = 3
+        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())
         if self.llm:
             # This may be mutating the shared llm object and needs further evaluation
             existing_stop = getattr(self.llm, "stop", [])
@@ -226,6 +234,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                     from_task=self.task,
                     from_agent=self.agent,
                     response_model=self.response_model,
+                    executor_context=self,
                 )
                 formatted_answer = process_llm_response(answer, self.use_stop_words)  # type: ignore[assignment]
 

lib/crewai/src/crewai/crew.py

@@ -809,6 +809,7 @@ class Crew(FlowTrackable, BaseModel):
                 "json_dict": output.json_dict,
                 "output_format": output.output_format,
                 "agent": output.agent,
+                "messages": output.messages,
             },
             "task_index": task_index,
             "inputs": inputs,
@@ -1236,6 +1237,7 @@ class Crew(FlowTrackable, BaseModel):
                 pydantic=stored_output["pydantic"],
                 json_dict=stored_output["json_dict"],
                 output_format=stored_output["output_format"],
+                messages=stored_output.get("messages", []),
             )
             self.tasks[i].output = task_output
 

lib/crewai/src/crewai/lite_agent.py

@@ -358,6 +358,7 @@ class LiteAgent(FlowTrackable, BaseModel):
             pydantic=formatted_result,
             agent_role=self.role,
             usage_metrics=usage_metrics.model_dump() if usage_metrics else None,
+            messages=self._messages,
         )
 
         # Process guardrail if set

lib/crewai/src/crewai/lite_agent_output.py

@@ -6,6 +6,8 @@ from typing import Any
 
 from pydantic import BaseModel, Field
 
+from crewai.utilities.types import LLMMessage
+
 
 class LiteAgentOutput(BaseModel):
     """Class that represents the result of a LiteAgent execution."""
@@ -20,6 +22,7 @@ class LiteAgentOutput(BaseModel):
     usage_metrics: dict[str, Any] | None = Field(
         description="Token usage metrics for this execution", default=None
     )
+    messages: list[LLMMessage] = Field(description="Messages of the agent", default=[])
 
     def to_dict(self) -> dict[str, Any]:
         """Convert pydantic_output to a dictionary."""

lib/crewai/src/crewai/task.py

@@ -539,6 +539,7 @@ class Task(BaseModel):
                 json_dict=json_output,
                 agent=agent.role,
                 output_format=self._get_output_format(),
+                messages=agent.last_messages,
             )
 
             if self._guardrails:
@@ -949,6 +950,7 @@ Follow these guidelines:
                 json_dict=json_output,
                 agent=agent.role,
                 output_format=self._get_output_format(),
+                messages=agent.last_messages,
             )
 
         return task_output

lib/crewai/src/crewai/tasks/task_output.py

@@ -6,6 +6,7 @@ from typing import Any
 from pydantic import BaseModel, Field, model_validator
 
 from crewai.tasks.output_format import OutputFormat
+from crewai.utilities.types import LLMMessage
 
 
 class TaskOutput(BaseModel):
@@ -40,6 +41,7 @@ class TaskOutput(BaseModel):
     output_format: OutputFormat = Field(
         description="Output format of the task", default=OutputFormat.RAW
     )
+    messages: list[LLMMessage] = Field(description="Messages of the task", default=[])
 
     @model_validator(mode="after")
     def set_summary(self):

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

@@ -33,6 +33,7 @@ from crewai.utilities.types import LLMMessage
 
 if TYPE_CHECKING:
     from crewai.agent import Agent
+    from crewai.agents.crew_agent_executor import CrewAgentExecutor
     from crewai.lite_agent import LiteAgent
     from crewai.llm import LLM
     from crewai.task import Task
@@ -51,40 +52,6 @@ class SummaryContent(TypedDict):
 console = Console()
 
 _MULTIPLE_NEWLINES: Final[re.Pattern[str]] = re.compile(r"\n+")
-_REACT_FIELD_PATTERN: Final[re.Pattern[str]] = re.compile(
-    r"^(Thought|Action|Action Input|Observation):\s*",
-    re.MULTILINE
-)
-
-
-def sanitize_react_output(text: str) -> str:
-    """Sanitize agent output by removing internal ReAct fields.
-
-    This function removes lines that start with internal ReAct formatting
-    markers like "Thought:", "Action:", "Action Input:", and "Observation:".
-    These fields are used internally by the agent execution loop but should
-    not be exposed in final user-facing outputs.
-
-    Args:
-        text: The raw agent output text that may contain ReAct fields.
-
-    Returns:
-        Sanitized text with internal ReAct fields removed.
-    """
-    if not text:
-        return text
-
-    lines = text.split("\n")
-    sanitized_lines = [
-        line for line in lines if not _REACT_FIELD_PATTERN.match(line)
-    ]
-
-    result = "\n".join(sanitized_lines).strip()
-
-    if not result:
-        return "Unable to complete the task."
-
-    return result
 
 
 def parse_tools(tools: list[BaseTool]) -> list[CrewStructuredTool]:
@@ -207,13 +174,10 @@ def handle_max_iterations_exceeded(
     # If format_answer returned an AgentAction, convert it to AgentFinish
     if isinstance(formatted, AgentFinish):
         return formatted
-
-    sanitized_output = sanitize_react_output(formatted.text)
-
     return AgentFinish(
         thought=formatted.thought,
-        output=sanitized_output,
-        text=sanitized_output,
+        output=formatted.text,
+        text=formatted.text,
     )
 
 
@@ -246,11 +210,10 @@ def format_answer(answer: str) -> AgentAction | AgentFinish:
     try:
         return parse(answer)
     except Exception:
-        sanitized_output = sanitize_react_output(answer)
         return AgentFinish(
             thought="Failed to parse LLM response",
-            output=sanitized_output,
-            text=sanitized_output,
+            output=answer,
+            text=answer,
         )
 
 
@@ -274,6 +237,7 @@ def get_llm_response(
     from_task: Task | None = None,
     from_agent: Agent | LiteAgent | None = None,
     response_model: type[BaseModel] | None = None,
+    executor_context: CrewAgentExecutor | None = None,
 ) -> str:
     """Call the LLM and return the response, handling any invalid responses.
 
@@ -285,6 +249,7 @@ def get_llm_response(
         from_task: Optional task context for the LLM call
         from_agent: Optional agent context for the LLM call
         response_model: Optional Pydantic model for structured outputs
+        executor_context: Optional executor context for hook invocation
 
     Returns:
         The response from the LLM as a string
@@ -293,6 +258,11 @@ def get_llm_response(
         Exception: If an error occurs.
         ValueError: If the response is None or empty.
     """
+
+    if executor_context is not None:
+        _setup_before_llm_call_hooks(executor_context, printer)
+        messages = executor_context.messages
+
     try:
         answer = llm.call(
             messages,
@@ -310,7 +280,7 @@ def get_llm_response(
         )
         raise ValueError("Invalid response from LLM call - None or empty.")
 
-    return answer
+    return _setup_after_llm_call_hooks(executor_context, answer, printer)
 
 
 def process_llm_response(
@@ -699,3 +669,92 @@ def load_agent_from_repository(from_repository: str) -> dict[str, Any]:
             else:
                 attributes[key] = value
     return attributes
+
+
+def _setup_before_llm_call_hooks(
+    executor_context: CrewAgentExecutor | None, printer: Printer
+) -> None:
+    """Setup and invoke before_llm_call hooks for the executor context.
+
+    Args:
+        executor_context: The executor context to setup the hooks for.
+        printer: Printer instance for error logging.
+    """
+    if executor_context and executor_context.before_llm_call_hooks:
+        from crewai.utilities.llm_call_hooks import LLMCallHookContext
+
+        original_messages = executor_context.messages
+
+        hook_context = LLMCallHookContext(executor_context)
+        try:
+            for hook in executor_context.before_llm_call_hooks:
+                hook(hook_context)
+        except Exception as e:
+            printer.print(
+                content=f"Error in before_llm_call hook: {e}",
+                color="yellow",
+            )
+
+        if not isinstance(executor_context.messages, list):
+            printer.print(
+                content=(
+                    "Warning: before_llm_call hook replaced messages with non-list. "
+                    "Restoring original messages list. Hooks should modify messages in-place, "
+                    "not replace the list (e.g., use context.messages.append() not context.messages = [])."
+                ),
+                color="yellow",
+            )
+            if isinstance(original_messages, list):
+                executor_context.messages = original_messages
+            else:
+                executor_context.messages = []
+
+
+def _setup_after_llm_call_hooks(
+    executor_context: CrewAgentExecutor | None,
+    answer: str,
+    printer: Printer,
+) -> str:
+    """Setup and invoke after_llm_call hooks for the executor context.
+
+    Args:
+        executor_context: The executor context to setup the hooks for.
+        answer: The LLM response string.
+        printer: Printer instance for error logging.
+
+    Returns:
+        The potentially modified response string.
+    """
+    if executor_context and executor_context.after_llm_call_hooks:
+        from crewai.utilities.llm_call_hooks import LLMCallHookContext
+
+        original_messages = executor_context.messages
+
+        hook_context = LLMCallHookContext(executor_context, response=answer)
+        try:
+            for hook in executor_context.after_llm_call_hooks:
+                modified_response = hook(hook_context)
+                if modified_response is not None and isinstance(modified_response, str):
+                    answer = modified_response
+
+        except Exception as e:
+            printer.print(
+                content=f"Error in after_llm_call hook: {e}",
+                color="yellow",
+            )
+
+        if not isinstance(executor_context.messages, list):
+            printer.print(
+                content=(
+                    "Warning: after_llm_call hook replaced messages with non-list. "
+                    "Restoring original messages list. Hooks should modify messages in-place, "
+                    "not replace the list (e.g., use context.messages.append() not context.messages = [])."
+                ),
+                color="yellow",
+            )
+            if isinstance(original_messages, list):
+                executor_context.messages = original_messages
+            else:
+                executor_context.messages = []
+
+    return answer

lib/crewai/src/crewai/utilities/llm_call_hooks.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING
+
+
+if TYPE_CHECKING:
+    from crewai.agents.crew_agent_executor import CrewAgentExecutor
+
+
+class LLMCallHookContext:
+    """Context object passed to LLM call hooks with full executor access.
+
+    Provides hooks with complete access to the executor state, allowing
+    modification of messages, responses, and executor attributes.
+
+    Attributes:
+        executor: Full reference to the CrewAgentExecutor instance
+        messages: Direct reference to executor.messages (mutable list).
+            Can be modified in both before_llm_call and after_llm_call hooks.
+            Modifications in after_llm_call hooks persist to the next iteration,
+            allowing hooks to modify conversation history for subsequent LLM calls.
+            IMPORTANT: Modify messages in-place (e.g., append, extend, remove items).
+            Do NOT replace the list (e.g., context.messages = []), as this will break
+            the executor. Use context.messages.append() or context.messages.extend()
+            instead of assignment.
+        agent: Reference to the agent executing the task
+        task: Reference to the task being executed
+        crew: Reference to the crew instance
+        llm: Reference to the LLM instance
+        iterations: Current iteration count
+        response: LLM response string (only set for after_llm_call hooks).
+            Can be modified by returning a new string from after_llm_call hook.
+    """
+
+    def __init__(
+        self,
+        executor: CrewAgentExecutor,
+        response: str | None = None,
+    ) -> None:
+        """Initialize hook context with executor reference.
+
+        Args:
+            executor: The CrewAgentExecutor instance
+            response: Optional response string (for after_llm_call hooks)
+        """
+        self.executor = executor
+        self.messages = executor.messages
+        self.agent = executor.agent
+        self.task = executor.task
+        self.crew = executor.crew
+        self.llm = executor.llm
+        self.iterations = executor.iterations
+        self.response = response
+
+
+# Global hook registries (optional convenience feature)
+_before_llm_call_hooks: list[Callable[[LLMCallHookContext], None]] = []
+_after_llm_call_hooks: list[Callable[[LLMCallHookContext], str | None]] = []
+
+
+def register_before_llm_call_hook(
+    hook: Callable[[LLMCallHookContext], None],
+) -> None:
+    """Register a global before_llm_call hook.
+
+    Global hooks are added to all executors automatically.
+    This is a convenience function for registering hooks that should
+    apply to all LLM calls across all executors.
+
+    Args:
+        hook: Function that receives LLMCallHookContext and can modify
+            context.messages directly. Should return None.
+            IMPORTANT: Modify messages in-place (append, extend, remove items).
+            Do NOT replace the list (context.messages = []), as this will break execution.
+    """
+    _before_llm_call_hooks.append(hook)
+
+
+def register_after_llm_call_hook(
+    hook: Callable[[LLMCallHookContext], str | None],
+) -> None:
+    """Register a global after_llm_call hook.
+
+    Global hooks are added to all executors automatically.
+    This is a convenience function for registering hooks that should
+    apply to all LLM calls across all executors.
+
+    Args:
+        hook: Function that receives LLMCallHookContext and can modify:
+            - The response: Return modified response string or None to keep original
+            - The messages: Modify context.messages directly (mutable reference)
+            Both modifications are supported and can be used together.
+            IMPORTANT: Modify messages in-place (append, extend, remove items).
+            Do NOT replace the list (context.messages = []), as this will break execution.
+    """
+    _after_llm_call_hooks.append(hook)
+
+
+def get_before_llm_call_hooks() -> list[Callable[[LLMCallHookContext], None]]:
+    """Get all registered global before_llm_call hooks.
+
+    Returns:
+        List of registered before hooks
+    """
+    return _before_llm_call_hooks.copy()
+
+
+def get_after_llm_call_hooks() -> list[Callable[[LLMCallHookContext], str | None]]:
+    """Get all registered global after_llm_call hooks.
+
+    Returns:
+        List of registered after hooks
+    """
+    return _after_llm_call_hooks.copy()

lib/crewai/src/crewai/utilities/types.py

@@ -1,6 +1,8 @@
 """Types for CrewAI utilities."""
 
-from typing import Any, Literal, TypedDict
+from typing import Any, Literal
+
+from typing_extensions import TypedDict
 
 
 class LLMMessage(TypedDict):

lib/crewai/tests/a2a/test_resolve_agent_identifier.py

@@ -0,0 +1,245 @@
+"""Test resolve_agent_identifier function for A2A skill ID resolution."""
+
+import pytest
+from a2a.types import AgentCapabilities, AgentCard, AgentSkill
+
+from crewai.a2a.config import A2AConfig
+from crewai.a2a.utils import resolve_agent_identifier
+
+
+@pytest.fixture
+def sample_agent_configs():
+    """Create sample A2A agent configurations."""
+    return [
+        A2AConfig(endpoint="http://localhost:10001/.well-known/agent-card.json"),
+        A2AConfig(endpoint="http://localhost:10002/.well-known/agent-card.json"),
+    ]
+
+
+@pytest.fixture
+def sample_agent_cards():
+    """Create sample AgentCards with skills."""
+    card1 = AgentCard(
+        name="Research Agent",
+        description="An expert research agent",
+        url="http://localhost:10001",
+        version="1.0.0",
+        capabilities=AgentCapabilities(),
+        default_input_modes=["text/plain"],
+        default_output_modes=["text/plain"],
+        skills=[
+            AgentSkill(
+                id="Research",
+                name="Research",
+                description="Conduct comprehensive research",
+                tags=["research", "analysis"],
+                examples=["Research quantum computing"],
+            )
+        ],
+    )
+
+    card2 = AgentCard(
+        name="Writing Agent",
+        description="An expert writing agent",
+        url="http://localhost:10002",
+        version="1.0.0",
+        capabilities=AgentCapabilities(),
+        default_input_modes=["text/plain"],
+        default_output_modes=["text/plain"],
+        skills=[
+            AgentSkill(
+                id="Writing",
+                name="Writing",
+                description="Write high-quality content",
+                tags=["writing", "content"],
+                examples=["Write a blog post"],
+            )
+        ],
+    )
+
+    return {
+        "http://localhost:10001/.well-known/agent-card.json": card1,
+        "http://localhost:10002/.well-known/agent-card.json": card2,
+    }
+
+
+def test_resolve_endpoint_passthrough(sample_agent_configs, sample_agent_cards):
+    """Test that endpoint URLs are returned as-is."""
+    endpoint = "http://localhost:10001/.well-known/agent-card.json"
+    result = resolve_agent_identifier(endpoint, sample_agent_configs, sample_agent_cards)
+    assert result == endpoint
+
+
+def test_resolve_unique_skill_id(sample_agent_configs, sample_agent_cards):
+    """Test that a unique skill ID resolves to the correct endpoint."""
+    result = resolve_agent_identifier("Research", sample_agent_configs, sample_agent_cards)
+    assert result == "http://localhost:10001/.well-known/agent-card.json"
+
+    result = resolve_agent_identifier("Writing", sample_agent_configs, sample_agent_cards)
+    assert result == "http://localhost:10002/.well-known/agent-card.json"
+
+
+def test_resolve_unknown_identifier(sample_agent_configs, sample_agent_cards):
+    """Test that unknown identifiers raise a descriptive error."""
+    with pytest.raises(ValueError) as exc_info:
+        resolve_agent_identifier("UnknownSkill", sample_agent_configs, sample_agent_cards)
+
+    error_msg = str(exc_info.value)
+    assert "Unknown A2A agent identifier 'UnknownSkill'" in error_msg
+    assert "Available endpoints:" in error_msg
+    assert "Available skill IDs:" in error_msg
+    assert "Research" in error_msg
+    assert "Writing" in error_msg
+
+
+def test_resolve_ambiguous_skill_id():
+    """Test that ambiguous skill IDs raise a descriptive error."""
+    configs = [
+        A2AConfig(endpoint="http://localhost:10001/.well-known/agent-card.json"),
+        A2AConfig(endpoint="http://localhost:10002/.well-known/agent-card.json"),
+    ]
+
+    card1 = AgentCard(
+        name="Research Agent 1",
+        description="First research agent",
+        url="http://localhost:10001",
+        version="1.0.0",
+        capabilities=AgentCapabilities(),
+        default_input_modes=["text/plain"],
+        default_output_modes=["text/plain"],
+        skills=[
+            AgentSkill(
+                id="Research",
+                name="Research",
+                description="Conduct research",
+                tags=["research"],
+                examples=["Research topic"],
+            )
+        ],
+    )
+
+    card2 = AgentCard(
+        name="Research Agent 2",
+        description="Second research agent",
+        url="http://localhost:10002",
+        version="1.0.0",
+        capabilities=AgentCapabilities(),
+        default_input_modes=["text/plain"],
+        default_output_modes=["text/plain"],
+        skills=[
+            AgentSkill(
+                id="Research",
+                name="Research",
+                description="Conduct research",
+                tags=["research"],
+                examples=["Research topic"],
+            )
+        ],
+    )
+
+    cards = {
+        "http://localhost:10001/.well-known/agent-card.json": card1,
+        "http://localhost:10002/.well-known/agent-card.json": card2,
+    }
+
+    with pytest.raises(ValueError) as exc_info:
+        resolve_agent_identifier("Research", configs, cards)
+
+    error_msg = str(exc_info.value)
+    assert "Ambiguous skill ID 'Research'" in error_msg
+    assert "found in multiple agents" in error_msg
+    assert "http://localhost:10001/.well-known/agent-card.json" in error_msg
+    assert "http://localhost:10002/.well-known/agent-card.json" in error_msg
+    assert "Please use the specific endpoint URL to disambiguate" in error_msg
+
+
+def test_resolve_with_no_skills():
+    """Test resolution when agent cards have no skills."""
+    configs = [
+        A2AConfig(endpoint="http://localhost:10001/.well-known/agent-card.json"),
+    ]
+
+    card = AgentCard(
+        name="Agent Without Skills",
+        description="An agent without skills",
+        url="http://localhost:10001",
+        version="1.0.0",
+        capabilities=AgentCapabilities(),
+        default_input_modes=["text/plain"],
+        default_output_modes=["text/plain"],
+        skills=[],
+    )
+
+    cards = {
+        "http://localhost:10001/.well-known/agent-card.json": card,
+    }
+
+    result = resolve_agent_identifier(
+        "http://localhost:10001/.well-known/agent-card.json", configs, cards
+    )
+    assert result == "http://localhost:10001/.well-known/agent-card.json"
+
+    with pytest.raises(ValueError) as exc_info:
+        resolve_agent_identifier("SomeSkill", configs, cards)
+
+    error_msg = str(exc_info.value)
+    assert "Unknown A2A agent identifier 'SomeSkill'" in error_msg
+    assert "Available skill IDs: none" in error_msg
+
+
+def test_resolve_with_multiple_skills_same_card(sample_agent_configs):
+    """Test resolution when a card has multiple skills."""
+    card = AgentCard(
+        name="Multi-Skill Agent",
+        description="An agent with multiple skills",
+        url="http://localhost:10001",
+        version="1.0.0",
+        capabilities=AgentCapabilities(),
+        default_input_modes=["text/plain"],
+        default_output_modes=["text/plain"],
+        skills=[
+            AgentSkill(
+                id="Research",
+                name="Research",
+                description="Conduct research",
+                tags=["research"],
+                examples=["Research topic"],
+            ),
+            AgentSkill(
+                id="Analysis",
+                name="Analysis",
+                description="Analyze data",
+                tags=["analysis"],
+                examples=["Analyze data"],
+            ),
+        ],
+    )
+
+    cards = {
+        "http://localhost:10001/.well-known/agent-card.json": card,
+    }
+
+    result1 = resolve_agent_identifier("Research", sample_agent_configs[:1], cards)
+    assert result1 == "http://localhost:10001/.well-known/agent-card.json"
+
+    result2 = resolve_agent_identifier("Analysis", sample_agent_configs[:1], cards)
+    assert result2 == "http://localhost:10001/.well-known/agent-card.json"
+
+
+def test_resolve_empty_agent_cards():
+    """Test resolution with empty agent cards dictionary."""
+    configs = [
+        A2AConfig(endpoint="http://localhost:10001/.well-known/agent-card.json"),
+    ]
+    cards = {}
+
+    result = resolve_agent_identifier(
+        "http://localhost:10001/.well-known/agent-card.json", configs, cards
+    )
+    assert result == "http://localhost:10001/.well-known/agent-card.json"
+
+    with pytest.raises(ValueError) as exc_info:
+        resolve_agent_identifier("SomeSkill", configs, cards)
+
+    error_msg = str(exc_info.value)
+    assert "Unknown A2A agent identifier 'SomeSkill'" in error_msg

lib/crewai/tests/a2a/test_skill_id_integration.py

@@ -0,0 +1,287 @@
+"""Integration test for A2A skill ID resolution (issue #3897)."""
+
+import pytest
+from a2a.types import AgentCapabilities, AgentCard, AgentSkill
+from pydantic import BaseModel
+
+from crewai.a2a.config import A2AConfig
+from crewai.a2a.utils import (
+    create_agent_response_model,
+    extract_agent_identifiers_from_cards,
+    resolve_agent_identifier,
+)
+
+
+def test_skill_id_resolution_integration():
+    """Test the complete flow of skill ID resolution as described in issue #3897.
+    
+    This test replicates the exact scenario from the bug report:
+    1. User creates A2A config with endpoint URL
+    2. Remote agent has AgentCard with skill.id="Research"
+    3. LLM returns a2a_ids=["Research"] instead of the endpoint URL
+    4. System should resolve "Research" to the endpoint and proceed successfully
+    """
+    a2a_config = A2AConfig(
+        endpoint="http://localhost:10001/.well-known/agent-card.json"
+    )
+    a2a_agents = [a2a_config]
+    
+    agent_card = AgentCard(
+        name="Research Agent",
+        description="An expert research agent that can conduct thorough research",
+        url="http://localhost:10001",
+        version="1.0.0",
+        capabilities=AgentCapabilities(),
+        default_input_modes=["text/plain"],
+        default_output_modes=["text/plain"],
+        skills=[
+            AgentSkill(
+                id="Research",
+                name="Research",
+                description="Conduct comprehensive research on any topic",
+                tags=["research", "analysis", "information-gathering"],
+                examples=[
+                    "Research the latest developments in quantum computing",
+                    "What are the current trends in renewable energy?",
+                ],
+            )
+        ],
+    )
+    
+    agent_cards = {
+        "http://localhost:10001/.well-known/agent-card.json": agent_card
+    }
+    
+    identifiers = extract_agent_identifiers_from_cards(a2a_agents, agent_cards)
+    
+    assert "http://localhost:10001/.well-known/agent-card.json" in identifiers
+    assert "Research" in identifiers
+    
+    agent_response_model = create_agent_response_model(identifiers)
+    
+    agent_response_data = {
+        "a2a_ids": ["Research"],  # LLM uses skill ID instead of endpoint
+        "message": "Please research quantum computing developments",
+        "is_a2a": True,
+    }
+    
+    agent_response = agent_response_model.model_validate(agent_response_data)
+    assert agent_response.a2a_ids == ("Research",)
+    assert agent_response.message == "Please research quantum computing developments"
+    assert agent_response.is_a2a is True
+    
+    resolved_endpoint = resolve_agent_identifier(
+        "Research", a2a_agents, agent_cards
+    )
+    assert resolved_endpoint == "http://localhost:10001/.well-known/agent-card.json"
+    
+    resolved_endpoint_direct = resolve_agent_identifier(
+        "http://localhost:10001/.well-known/agent-card.json",
+        a2a_agents,
+        agent_cards,
+    )
+    assert resolved_endpoint_direct == "http://localhost:10001/.well-known/agent-card.json"
+
+
+def test_skill_id_validation_error_before_fix():
+    """Test that demonstrates the original bug (for documentation purposes).
+    
+    Before the fix, creating an AgentResponse model with only endpoints
+    would cause a validation error when the LLM returned a skill ID.
+    """
+    endpoints_only = ("http://localhost:10001/.well-known/agent-card.json",)
+    agent_response_model_old = create_agent_response_model(endpoints_only)
+    
+    agent_response_data = {
+        "a2a_ids": ["Research"],
+        "message": "Please research quantum computing",
+        "is_a2a": True,
+    }
+    
+    with pytest.raises(Exception) as exc_info:
+        agent_response_model_old.model_validate(agent_response_data)
+    
+    error_msg = str(exc_info.value)
+    assert "validation error" in error_msg.lower() or "literal" in error_msg.lower()
+
+
+def test_multiple_agents_with_unique_skill_ids():
+    """Test that multiple agents with unique skill IDs work correctly."""
+    a2a_agents = [
+        A2AConfig(endpoint="http://localhost:10001/.well-known/agent-card.json"),
+        A2AConfig(endpoint="http://localhost:10002/.well-known/agent-card.json"),
+    ]
+    
+    card1 = AgentCard(
+        name="Research Agent",
+        description="Research agent",
+        url="http://localhost:10001",
+        version="1.0.0",
+        capabilities=AgentCapabilities(),
+        default_input_modes=["text/plain"],
+        default_output_modes=["text/plain"],
+        skills=[
+            AgentSkill(
+                id="Research",
+                name="Research",
+                description="Conduct research",
+                tags=["research"],
+            )
+        ],
+    )
+    
+    card2 = AgentCard(
+        name="Writing Agent",
+        description="Writing agent",
+        url="http://localhost:10002",
+        version="1.0.0",
+        capabilities=AgentCapabilities(),
+        default_input_modes=["text/plain"],
+        default_output_modes=["text/plain"],
+        skills=[
+            AgentSkill(
+                id="Writing",
+                name="Writing",
+                description="Write content",
+                tags=["writing"],
+            )
+        ],
+    )
+    
+    agent_cards = {
+        "http://localhost:10001/.well-known/agent-card.json": card1,
+        "http://localhost:10002/.well-known/agent-card.json": card2,
+    }
+    
+    identifiers = extract_agent_identifiers_from_cards(a2a_agents, agent_cards)
+    
+    assert len(identifiers) == 4
+    assert "http://localhost:10001/.well-known/agent-card.json" in identifiers
+    assert "http://localhost:10002/.well-known/agent-card.json" in identifiers
+    assert "Research" in identifiers
+    assert "Writing" in identifiers
+    
+    agent_response_model = create_agent_response_model(identifiers)
+    
+    response1 = agent_response_model.model_validate({
+        "a2a_ids": ["Research"],
+        "message": "Do research",
+        "is_a2a": True,
+    })
+    assert response1.a2a_ids == ("Research",)
+    
+    response2 = agent_response_model.model_validate({
+        "a2a_ids": ["Writing"],
+        "message": "Write content",
+        "is_a2a": True,
+    })
+    assert response2.a2a_ids == ("Writing",)
+    
+    endpoint1 = resolve_agent_identifier("Research", a2a_agents, agent_cards)
+    assert endpoint1 == "http://localhost:10001/.well-known/agent-card.json"
+    
+    endpoint2 = resolve_agent_identifier("Writing", a2a_agents, agent_cards)
+    assert endpoint2 == "http://localhost:10002/.well-known/agent-card.json"
+
+
+def test_multi_turn_skill_id_resolution():
+    """Test that skill IDs work in multi-turn A2A conversations.
+    
+    This test verifies the fix in _handle_agent_response_and_continue()
+    that rebuilds the AgentResponse model with both endpoints and skill IDs
+    for subsequent turns in multi-turn conversations.
+    
+    Scenario:
+    1. First turn: LLM returns skill ID "Research"
+    2. A2A agent responds
+    3. Second turn: LLM returns skill ID "Writing" (different agent)
+    4. Both turns should accept skill IDs without validation errors
+    """
+    a2a_agents = [
+        A2AConfig(endpoint="http://localhost:10001/.well-known/agent-card.json"),
+        A2AConfig(endpoint="http://localhost:10002/.well-known/agent-card.json"),
+    ]
+    
+    card1 = AgentCard(
+        name="Research Agent",
+        description="Research agent",
+        url="http://localhost:10001",
+        version="1.0.0",
+        capabilities=AgentCapabilities(),
+        default_input_modes=["text/plain"],
+        default_output_modes=["text/plain"],
+        skills=[
+            AgentSkill(
+                id="Research",
+                name="Research",
+                description="Conduct research",
+                tags=["research"],
+            )
+        ],
+    )
+    
+    card2 = AgentCard(
+        name="Writing Agent",
+        description="Writing agent",
+        url="http://localhost:10002",
+        version="1.0.0",
+        capabilities=AgentCapabilities(),
+        default_input_modes=["text/plain"],
+        default_output_modes=["text/plain"],
+        skills=[
+            AgentSkill(
+                id="Writing",
+                name="Writing",
+                description="Write content",
+                tags=["writing"],
+            )
+        ],
+    )
+    
+    agent_cards_turn1 = {
+        "http://localhost:10001/.well-known/agent-card.json": card1,
+    }
+    
+    identifiers_turn1 = extract_agent_identifiers_from_cards(a2a_agents, agent_cards_turn1)
+    model_turn1 = create_agent_response_model(identifiers_turn1)
+    
+    response_turn1 = model_turn1.model_validate({
+        "a2a_ids": ["Research"],
+        "message": "Please research quantum computing",
+        "is_a2a": True,
+    })
+    assert response_turn1.a2a_ids == ("Research",)
+    
+    endpoint_turn1 = resolve_agent_identifier("Research", a2a_agents, agent_cards_turn1)
+    assert endpoint_turn1 == "http://localhost:10001/.well-known/agent-card.json"
+    
+    agent_cards_turn2 = {
+        "http://localhost:10001/.well-known/agent-card.json": card1,
+        "http://localhost:10002/.well-known/agent-card.json": card2,
+    }
+    
+    identifiers_turn2 = extract_agent_identifiers_from_cards(a2a_agents, agent_cards_turn2)
+    model_turn2 = create_agent_response_model(identifiers_turn2)
+    
+    assert "Research" in identifiers_turn2
+    assert "Writing" in identifiers_turn2
+    
+    response_turn2 = model_turn2.model_validate({
+        "a2a_ids": ["Writing"],
+        "message": "Now write a report based on the research",
+        "is_a2a": True,
+    })
+    assert response_turn2.a2a_ids == ("Writing",)
+    
+    endpoint_turn2 = resolve_agent_identifier("Writing", a2a_agents, agent_cards_turn2)
+    assert endpoint_turn2 == "http://localhost:10002/.well-known/agent-card.json"
+    
+    response_turn3 = model_turn2.model_validate({
+        "a2a_ids": ["Research"],
+        "message": "Research more details",
+        "is_a2a": True,
+    })
+    assert response_turn3.a2a_ids == ("Research",)
+    
+    endpoint_turn3 = resolve_agent_identifier("Research", a2a_agents, agent_cards_turn2)
+    assert endpoint_turn3 == "http://localhost:10001/.well-known/agent-card.json"

lib/crewai/tests/agents/test_agent.py

@@ -2714,3 +2714,293 @@ def test_agent_without_apps_no_platform_tools():
 
     tools = crew._prepare_tools(agent, task, [])
     assert tools == []
+
+
+@pytest.mark.vcr(filter_headers=["authorization"])
+def test_before_llm_call_hook_modifies_messages():
+    """Test that before_llm_call hooks can modify messages."""
+    from crewai.utilities.llm_call_hooks import LLMCallHookContext, register_before_llm_call_hook
+
+    hook_called = False
+    original_message_count = 0
+
+    def before_hook(context: LLMCallHookContext) -> None:
+        nonlocal hook_called, original_message_count
+        hook_called = True
+        original_message_count = len(context.messages)
+        context.messages.append({
+            "role": "user",
+            "content": "Additional context: This is a test modification."
+        })
+
+    register_before_llm_call_hook(before_hook)
+
+    try:
+        agent = Agent(
+            role="Test Agent",
+            goal="Test goal",
+            backstory="Test backstory",
+            allow_delegation=False,
+        )
+
+        task = Task(
+            description="Say hello",
+            expected_output="A greeting",
+            agent=agent,
+        )
+
+        result = agent.execute_task(task)
+
+        assert hook_called, "before_llm_call hook should have been called"
+        assert len(agent.agent_executor.messages) > original_message_count
+        assert result is not None
+    finally:
+        pass
+
+
+@pytest.mark.vcr(filter_headers=["authorization"])
+def test_after_llm_call_hook_modifies_messages_for_next_iteration():
+    """Test that after_llm_call hooks can modify messages for the next iteration."""
+    from crewai.utilities.llm_call_hooks import LLMCallHookContext, register_after_llm_call_hook
+
+    hook_call_count = 0
+    hook_iterations = []
+    messages_added_in_iteration_0 = False
+    test_message_content = "HOOK_ADDED_MESSAGE_FOR_NEXT_ITERATION"
+
+    def after_hook(context: LLMCallHookContext) -> str | None:
+        nonlocal hook_call_count, hook_iterations, messages_added_in_iteration_0
+        hook_call_count += 1
+        current_iteration = context.iterations
+        hook_iterations.append(current_iteration)
+
+        if current_iteration == 0:
+            messages_before = len(context.messages)
+            context.messages.append({
+                "role": "user",
+                "content": test_message_content
+            })
+            messages_added_in_iteration_0 = True
+            assert len(context.messages) == messages_before + 1
+
+        return None
+
+    register_after_llm_call_hook(after_hook)
+
+    try:
+        agent = Agent(
+            role="Test Agent",
+            goal="Test goal",
+            backstory="Test backstory",
+            allow_delegation=False,
+            max_iter=3,
+        )
+
+        task = Task(
+            description="Count to 3, taking your time",
+            expected_output="A count",
+            agent=agent,
+        )
+
+        result = agent.execute_task(task)
+
+        assert hook_call_count > 0, "after_llm_call hook should have been called"
+        assert messages_added_in_iteration_0, "Message should have been added in iteration 0"
+
+        executor_messages = agent.agent_executor.messages
+        message_contents = [msg.get("content", "") for msg in executor_messages if isinstance(msg, dict)]
+        assert any(test_message_content in content for content in message_contents), (
+            f"Message added by hook in iteration 0 should be present in executor messages. "
+            f"Messages: {message_contents}"
+        )
+
+        assert len(executor_messages) > 2, "Executor should have more than initial messages"
+        assert result is not None
+    finally:
+        pass
+
+
+@pytest.mark.vcr(filter_headers=["authorization"])
+def test_after_llm_call_hook_modifies_messages():
+    """Test that after_llm_call hooks can modify messages for next iteration."""
+    from crewai.utilities.llm_call_hooks import LLMCallHookContext, register_after_llm_call_hook
+
+    hook_called = False
+    messages_before_hook = 0
+
+    def after_hook(context: LLMCallHookContext) -> str | None:
+        nonlocal hook_called, messages_before_hook
+        hook_called = True
+        messages_before_hook = len(context.messages)
+        context.messages.append({
+            "role": "user",
+            "content": "Remember: This is iteration 2 context."
+        })
+        return None  # Don't modify response
+
+    register_after_llm_call_hook(after_hook)
+
+    try:
+        agent = Agent(
+            role="Test Agent",
+            goal="Test goal",
+            backstory="Test backstory",
+            allow_delegation=False,
+            max_iter=2,
+        )
+
+        task = Task(
+            description="Count to 2",
+            expected_output="A count",
+            agent=agent,
+        )
+
+        result = agent.execute_task(task)
+
+        assert hook_called, "after_llm_call hook should have been called"
+        assert len(agent.agent_executor.messages) > messages_before_hook
+        assert result is not None
+    finally:
+        pass
+
+
+@pytest.mark.vcr(filter_headers=["authorization"])
+def test_llm_call_hooks_with_crew():
+    """Test that LLM call hooks work with crew execution."""
+    from crewai.utilities.llm_call_hooks import (
+        LLMCallHookContext,
+        register_after_llm_call_hook,
+        register_before_llm_call_hook,
+    )
+
+    before_hook_called = False
+    after_hook_called = False
+
+    def before_hook(context: LLMCallHookContext) -> None:
+        nonlocal before_hook_called
+        before_hook_called = True
+        assert context.executor is not None
+        assert context.agent is not None
+        assert context.task is not None
+        context.messages.append({
+            "role": "system",
+            "content": "Additional system context from hook."
+        })
+
+    def after_hook(context: LLMCallHookContext) -> str | None:
+        nonlocal after_hook_called
+        after_hook_called = True
+        assert context.response is not None
+        assert len(context.messages) > 0
+        return None
+
+    register_before_llm_call_hook(before_hook)
+    register_after_llm_call_hook(after_hook)
+
+    try:
+        agent = Agent(
+            role="Researcher",
+            goal="Research topics",
+            backstory="You are a researcher",
+            allow_delegation=False,
+        )
+
+        task = Task(
+            description="Research AI frameworks",
+            expected_output="A research summary",
+            agent=agent,
+        )
+
+        crew = Crew(agents=[agent], tasks=[task])
+        result = crew.kickoff()
+
+        assert before_hook_called, "before_llm_call hook should have been called"
+        assert after_hook_called, "after_llm_call hook should have been called"
+        assert result is not None
+        assert result.raw is not None
+    finally:
+        pass
+
+
+@pytest.mark.vcr(filter_headers=["authorization"])
+def test_llm_call_hooks_can_modify_executor_attributes():
+    """Test that hooks can access and modify executor attributes like tools."""
+    from crewai.utilities.llm_call_hooks import LLMCallHookContext, register_before_llm_call_hook
+    from crewai.tools import tool
+
+    @tool
+    def test_tool() -> str:
+        """A test tool."""
+        return "test result"
+
+    hook_called = False
+    original_tools_count = 0
+
+    def before_hook(context: LLMCallHookContext) -> None:
+        nonlocal hook_called, original_tools_count
+        hook_called = True
+        original_tools_count = len(context.executor.tools)
+        assert context.executor.max_iter > 0
+        assert context.executor.iterations >= 0
+        assert context.executor.tools is not None
+
+    register_before_llm_call_hook(before_hook)
+
+    try:
+        agent = Agent(
+            role="Test Agent",
+            goal="Test goal",
+            backstory="Test backstory",
+            tools=[test_tool],
+            allow_delegation=False,
+        )
+
+        task = Task(
+            description="Use the test tool",
+            expected_output="Tool result",
+            agent=agent,
+        )
+
+        result = agent.execute_task(task)
+
+        assert hook_called, "before_llm_call hook should have been called"
+        assert original_tools_count >= 0
+        assert result is not None
+    finally:
+        pass
+
+
+@pytest.mark.vcr(filter_headers=["authorization"])
+def test_llm_call_hooks_error_handling():
+    """Test that hook errors don't break execution."""
+    from crewai.utilities.llm_call_hooks import LLMCallHookContext, register_before_llm_call_hook
+
+    hook_called = False
+
+    def error_hook(context: LLMCallHookContext) -> None:
+        nonlocal hook_called
+        hook_called = True
+        raise ValueError("Test hook error")
+
+    register_before_llm_call_hook(error_hook)
+
+    try:
+        agent = Agent(
+            role="Test Agent",
+            goal="Test goal",
+            backstory="Test backstory",
+            allow_delegation=False,
+        )
+
+        task = Task(
+            description="Say hello",
+            expected_output="A greeting",
+            agent=agent,
+        )
+
+        result = agent.execute_task(task)
+
+        assert hook_called, "before_llm_call hook should have been called"
+        assert result is not None
+    finally:
+        pass

lib/crewai/tests/agents/test_lite_agent.py

@@ -238,6 +238,27 @@ def test_lite_agent_returns_usage_metrics():
     assert result.usage_metrics["total_tokens"] > 0
 
 
+@pytest.mark.vcr(filter_headers=["authorization"])
+def test_lite_agent_output_includes_messages():
+    """Test that LiteAgentOutput includes messages from agent execution."""
+    llm = LLM(model="gpt-4o-mini")
+    agent = Agent(
+        role="Research Assistant",
+        goal="Find information about the population of Tokyo",
+        backstory="You are a helpful research assistant who can search for information about the population of Tokyo.",
+        llm=llm,
+        tools=[WebSearchTool()],
+        verbose=True,
+    )
+
+    result = agent.kickoff("What is the population of Tokyo?")
+
+    assert isinstance(result, LiteAgentOutput)
+    assert hasattr(result, "messages")
+    assert isinstance(result.messages, list)
+    assert len(result.messages) > 0
+
+
 @pytest.mark.vcr(filter_headers=["authorization"])
 @pytest.mark.asyncio
 async def test_lite_agent_returns_usage_metrics_async():

lib/crewai/tests/cassettes/test_after_llm_call_hook_modifies_messages.yaml

@@ -0,0 +1,126 @@
+interactions:
+- request:
+    body: '{"messages":[{"role":"system","content":"You are Test Agent. Test backstory\nYour
+      personal goal is: Test goal\nTo give my best complete final answer to the task
+      respond using the exact following format:\n\nThought: I now can give a great
+      answer\nFinal Answer: Your final answer must be the great and the most complete
+      as possible, it must be outcome described.\n\nI MUST use these formats, my job
+      depends on it!"},{"role":"user","content":"\nCurrent Task: Count to 2\n\nThis
+      is the expected criteria for your final answer: A count\nyou MUST return the
+      actual complete content as the final answer, not a summary.\n\nBegin! This is
+      VERY important to you, use the tools available and give your best Final Answer,
+      your job depends on it!\n\nThought:"},{"role":"user","content":"Additional context:
+      This is a test modification."}],"model":"gpt-4.1-mini"}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate, zstd
+      connection:
+      - keep-alive
+      content-length:
+      - '849'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.109.1
+      x-stainless-arch:
+      - arm64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - MacOS
+      x-stainless-package-version:
+      - 1.109.1
+      x-stainless-read-timeout:
+      - '600'
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAAAwAAAP//jFJNb5wwEL3zK0Y+QwSI7LLcokqVcujHoR9S2wg5ZsBujceyTdIo2v9e
+        GTYLaROpFyTmzXt+b2YeEwCmOtYAE5IHMVqdveH09UHKLx+/2eFzkAdZXL8XJPr9h3dFydLIoNuf
+        KMIT60LQaDUGRWaBhUMeMKoW+11ZH/K8rmZgpA51pA02ZNVFkY3KqKzMy8ssr7KiOtElKYGeNfA9
+        AQB4nL/RqOnwN2sgT58qI3rPB2TNuQmAOdKxwrj3ygduAktXUJAJaGbvnyRNgwwNXIOhexDcwKDu
+        EDgMMQBw4+/R/TBvleEarua/BooUyq2gw37yPKYyk9YbgBtDgcepzFFuTsjxbF7TYB3d+r+orFdG
+        edk65J5MNOoDWTajxwTgZh7S9Cw3s45GG9pAv3B+rtgdFj22LmeD1icwUOB6W9+nL+i1HQautN+M
+        mQkuJHYrdd0JnzpFGyDZpP7XzUvaS3Jlhv+RXwEh0AbsWuuwU+J54rXNYbzd19rOU54NM4/uTgls
+        g0IXN9Fhzye9HBTzDz7g2PbKDOisU8tV9batRFlfFn29K1lyTP4AAAD//wMApumqgWQDAAA=
+    headers:
+      CF-RAY:
+      - 99d044543db94e48-SJC
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 11 Nov 2025 19:41:25 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - __cf_bm=KLlCOQ_zxXquDvj96O28ObVFEoAbFE8R7zlmuiuXH1M-1762890085-1.0.1.1-UChItG1GnLDHrErY60dUpkbD3lEkSvfkTQpOmEtzd0fjjm_y1pJQiB.VDXVi2pPIMSelir0ZgiVXSh5.hGPb3RjQqbH3pv0Rr_2dQ59OIQ8;
+        path=/; expires=Tue, 11-Nov-25 20:11:25 GMT; domain=.api.openai.com; HttpOnly;
+        Secure; SameSite=None
+      - _cfuvid=u.Z6xV9tQd3ucK35BinKtlCkewcI6q_uQicyeEeeR18-1762890085355-0.0.1.1-604800000;
+        path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None
+      Strict-Transport-Security:
+      - max-age=31536000; includeSubDomains; preload
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - nosniff
+      access-control-expose-headers:
+      - X-Request-ID
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - crewai-iuxna1
+      openai-processing-ms:
+      - '559'
+      openai-project:
+      - proj_xitITlrFeen7zjNSzML82h9x
+      openai-version:
+      - '2020-10-01'
+      x-envoy-upstream-service-time:
+      - '735'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-project-tokens:
+      - '150000000'
+      x-ratelimit-limit-requests:
+      - '30000'
+      x-ratelimit-limit-tokens:
+      - '150000000'
+      x-ratelimit-remaining-project-tokens:
+      - '149999817'
+      x-ratelimit-remaining-requests:
+      - '29999'
+      x-ratelimit-remaining-tokens:
+      - '149999817'
+      x-ratelimit-reset-project-tokens:
+      - 0s
+      x-ratelimit-reset-requests:
+      - 2ms
+      x-ratelimit-reset-tokens:
+      - 0s
+      x-request-id:
+      - req_bcaa0f8500714ed09f967488b238ce2e
+    status:
+      code: 200
+      message: OK
+version: 1

lib/crewai/tests/cassettes/test_after_llm_call_hook_modifies_messages_for_next_iteration.yaml

@@ -0,0 +1,222 @@
+interactions:
+- request:
+    body: '{"trace_id": "aeb82647-004a-4a30-9481-d55f476d5659", "execution_type":
+      "crew", "user_identifier": null, "execution_context": {"crew_fingerprint": null,
+      "crew_name": "Unknown Crew", "flow_name": null, "crewai_version": "1.4.1", "privacy_level":
+      "standard"}, "execution_metadata": {"expected_duration_estimate": 300, "agent_count":
+      0, "task_count": 0, "flow_method_count": 0, "execution_started_at": "2025-11-11T19:45:17.648657+00:00"}}'
+    headers:
+      Accept:
+      - '*/*'
+      Accept-Encoding:
+      - gzip, deflate, zstd
+      Connection:
+      - keep-alive
+      Content-Length:
+      - '434'
+      Content-Type:
+      - application/json
+      User-Agent:
+      - CrewAI-CLI/1.4.1
+      X-Crewai-Version:
+      - 1.4.1
+    method: POST
+    uri: https://app.crewai.com/crewai_plus/api/v1/tracing/batches
+  response:
+    body:
+      string: '{"error":"bad_credentials","message":"Bad credentials"}'
+    headers:
+      Connection:
+      - keep-alive
+      Content-Length:
+      - '55'
+      Content-Type:
+      - application/json; charset=utf-8
+      Date:
+      - Tue, 11 Nov 2025 19:45:17 GMT
+      cache-control:
+      - no-store
+      content-security-policy:
+      - 'default-src ''self'' *.app.crewai.com app.crewai.com; script-src ''self''
+        ''unsafe-inline'' *.app.crewai.com app.crewai.com https://cdn.jsdelivr.net/npm/apexcharts
+        https://www.gstatic.com https://run.pstmn.io https://apis.google.com https://apis.google.com/js/api.js
+        https://accounts.google.com https://accounts.google.com/gsi/client https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.1/normalize.min.css.map
+        https://*.google.com https://docs.google.com https://slides.google.com https://js.hs-scripts.com
+        https://js.sentry-cdn.com https://browser.sentry-cdn.com https://www.googletagmanager.com
+        https://js-na1.hs-scripts.com https://js.hubspot.com http://js-na1.hs-scripts.com
+        https://bat.bing.com https://cdn.amplitude.com https://cdn.segment.com https://d1d3n03t5zntha.cloudfront.net/
+        https://descriptusercontent.com https://edge.fullstory.com https://googleads.g.doubleclick.net
+        https://js.hs-analytics.net https://js.hs-banner.com https://js.hsadspixel.net
+        https://js.hscollectedforms.net https://js.usemessages.com https://snap.licdn.com
+        https://static.cloudflareinsights.com https://static.reo.dev https://www.google-analytics.com
+        https://share.descript.com/; style-src ''self'' ''unsafe-inline'' *.app.crewai.com
+        app.crewai.com https://cdn.jsdelivr.net/npm/apexcharts; img-src ''self'' data:
+        *.app.crewai.com app.crewai.com https://zeus.tools.crewai.com https://dashboard.tools.crewai.com
+        https://cdn.jsdelivr.net https://forms.hsforms.com https://track.hubspot.com
+        https://px.ads.linkedin.com https://px4.ads.linkedin.com https://www.google.com
+        https://www.google.com.br; font-src ''self'' data: *.app.crewai.com app.crewai.com;
+        connect-src ''self'' *.app.crewai.com app.crewai.com https://zeus.tools.crewai.com
+        https://connect.useparagon.com/ https://zeus.useparagon.com/* https://*.useparagon.com/*
+        https://run.pstmn.io https://connect.tools.crewai.com/ https://*.sentry.io
+        https://www.google-analytics.com https://edge.fullstory.com https://rs.fullstory.com
+        https://api.hubspot.com https://forms.hscollectedforms.net https://api.hubapi.com
+        https://px.ads.linkedin.com https://px4.ads.linkedin.com https://google.com/pagead/form-data/16713662509
+        https://google.com/ccm/form-data/16713662509 https://www.google.com/ccm/collect
+        https://worker-actionkit.tools.crewai.com https://api.reo.dev; frame-src ''self''
+        *.app.crewai.com app.crewai.com https://connect.useparagon.com/ https://zeus.tools.crewai.com
+        https://zeus.useparagon.com/* https://connect.tools.crewai.com/ https://docs.google.com
+        https://drive.google.com https://slides.google.com https://accounts.google.com
+        https://*.google.com https://app.hubspot.com/ https://td.doubleclick.net https://www.googletagmanager.com/
+        https://www.youtube.com https://share.descript.com'
+      expires:
+      - '0'
+      permissions-policy:
+      - camera=(), microphone=(self), geolocation=()
+      pragma:
+      - no-cache
+      referrer-policy:
+      - strict-origin-when-cross-origin
+      strict-transport-security:
+      - max-age=63072000; includeSubDomains
+      vary:
+      - Accept
+      x-content-type-options:
+      - nosniff
+      x-frame-options:
+      - SAMEORIGIN
+      x-permitted-cross-domain-policies:
+      - none
+      x-request-id:
+      - 48a89b0d-206b-4c1b-aa0d-ecc3b4ab525c
+      x-runtime:
+      - '0.088251'
+      x-xss-protection:
+      - 1; mode=block
+    status:
+      code: 401
+      message: Unauthorized
+- request:
+    body: '{"messages":[{"role":"system","content":"You are Test Agent. Test backstory\nYour
+      personal goal is: Test goal\nTo give my best complete final answer to the task
+      respond using the exact following format:\n\nThought: I now can give a great
+      answer\nFinal Answer: Your final answer must be the great and the most complete
+      as possible, it must be outcome described.\n\nI MUST use these formats, my job
+      depends on it!"},{"role":"user","content":"\nCurrent Task: Count to 3, taking
+      your time\n\nThis is the expected criteria for your final answer: A count\nyou
+      MUST return the actual complete content as the final answer, not a summary.\n\nBegin!
+      This is VERY important to you, use the tools available and give your best Final
+      Answer, your job depends on it!\n\nThought:"}],"model":"gpt-4.1-mini"}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate, zstd
+      connection:
+      - keep-alive
+      content-length:
+      - '790'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.109.1
+      x-stainless-arch:
+      - arm64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - MacOS
+      x-stainless-package-version:
+      - 1.109.1
+      x-stainless-read-timeout:
+      - '600'
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAAAwAAAP//jFJNa9wwEL37Vww6r43tOpuNb2nKQgslOSy0NA1mIo9tdWVJSHK2Jex/
+        L/J+2Ns20IuE5s0bzXszrxEAEzUrgfEOPe+NjO9Q41atP3/79GG7vX8QD0Xq15svX9/fUd+yRWDo
+        5x/E/YmVcN0bSV5odYC5JfQUqmbXy3x1k77LViPQ65pkoLXGx0WSxb1QIs7T/CpOizgrjvROC06O
+        lfAYAQC8jmdoVNX0k5WQLk6RnpzDllh5TgJgVssQYeiccB6VZ4sJ5Fp5UmPvm04PbedL+AhK74Cj
+        gla8ECC0QQCgcjuy39VaKJRwO75KuFeUJAlsdnq8OkuUzD+w1AwOg0o1SDkDUCntMbg0Sns6Ivuz
+        GKlbY/Wz+4PKGqGE6ypL6LQKjTuvDRvRfQTwNJo2XPjAjNW98ZXXWxq/y5ZH09g0rBl6cwS99ihn
+        8esTcFGvqsmjkG5mO+PIO6on6jQjHGqhZ0A0U/13N/+qfVAuVPs/5SeAczKe6spYqgW/VDylWQq7
+        /Fba2eWxYebIvghOlRdkwyRqanCQhwVj7pfz1FeNUC1ZY8VhyxpTFTxfXWXNapmzaB/9BgAA//8D
+        AL0LXHV0AwAA
+    headers:
+      CF-RAY:
+      - 99d04a06dc4d1949-SJC
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 11 Nov 2025 19:45:18 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - __cf_bm=KnsnYxgmlpoHf.5TWnNgU30xb2tc0gK7SC2BbUkud2M-1762890318-1.0.1.1-3KeaQY59x5mY6n8DINELLaH9_b68w7W4ZZ0KeOknBHmQyDwx5qbtDonfYxOjsO_KykjtJLHpB0bsINSNEa9TrjNQHqUWTlRhldfTLenUG44;
+        path=/; expires=Tue, 11-Nov-25 20:15:18 GMT; domain=.api.openai.com; HttpOnly;
+        Secure; SameSite=None
+      - _cfuvid=ekC35NRP79GCMP.eTi_odl5.6DIsAeFEXKlanWUZOH4-1762890318589-0.0.1.1-604800000;
+        path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None
+      Strict-Transport-Security:
+      - max-age=31536000; includeSubDomains; preload
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - nosniff
+      access-control-expose-headers:
+      - X-Request-ID
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - crewai-iuxna1
+      openai-processing-ms:
+      - '598'
+      openai-project:
+      - proj_xitITlrFeen7zjNSzML82h9x
+      openai-version:
+      - '2020-10-01'
+      x-envoy-upstream-service-time:
+      - '632'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-project-tokens:
+      - '150000000'
+      x-ratelimit-limit-requests:
+      - '30000'
+      x-ratelimit-limit-tokens:
+      - '150000000'
+      x-ratelimit-remaining-project-tokens:
+      - '149999827'
+      x-ratelimit-remaining-requests:
+      - '29999'
+      x-ratelimit-remaining-tokens:
+      - '149999827'
+      x-ratelimit-reset-project-tokens:
+      - 0s
+      x-ratelimit-reset-requests:
+      - 2ms
+      x-ratelimit-reset-tokens:
+      - 0s
+      x-request-id:
+      - req_cb36cbe6c33b42a28675e8c6d9a36fe9
+    status:
+      code: 200
+      message: OK
+version: 1

lib/crewai/tests/cassettes/test_before_llm_call_hook_modifies_messages.yaml

@@ -0,0 +1,127 @@
+interactions:
+- request:
+    body: '{"messages":[{"role":"system","content":"You are Test Agent. Test backstory\nYour
+      personal goal is: Test goal\nTo give my best complete final answer to the task
+      respond using the exact following format:\n\nThought: I now can give a great
+      answer\nFinal Answer: Your final answer must be the great and the most complete
+      as possible, it must be outcome described.\n\nI MUST use these formats, my job
+      depends on it!"},{"role":"user","content":"\nCurrent Task: Say hello\n\nThis
+      is the expected criteria for your final answer: A greeting\nyou MUST return
+      the actual complete content as the final answer, not a summary.\n\nBegin! This
+      is VERY important to you, use the tools available and give your best Final Answer,
+      your job depends on it!\n\nThought:"},{"role":"user","content":"Additional context:
+      This is a test modification."}],"model":"gpt-4.1-mini"}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate, zstd
+      connection:
+      - keep-alive
+      content-length:
+      - '851'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.109.1
+      x-stainless-arch:
+      - arm64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - MacOS
+      x-stainless-package-version:
+      - 1.109.1
+      x-stainless-read-timeout:
+      - '600'
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAAAwAAAP//jFJdi9swEHz3r9jqOT5sk+RSvx2lJW1poXDQ0vYwirS21cpaIclJr0f+
+        +yE7F/s+Cn0xeGdnNLO7dwkAU5KVwETLg+isTt9w+rr/YESx27+93RaHVm4/ff7y8Vpcffv+ly0i
+        g3a/UIQH1oWgzmoMiswIC4c8YFTNL9fF5nWWbfIB6EiijrTGhnR5kaedMiotsmKVZss0X57oLSmB
+        npXwIwEAuBu+0aiR+IeVkC0eKh16zxtk5bkJgDnSscK498oHbgJbTKAgE9AM3q9b6ps2lPAeDB1A
+        cAON2iNwaGIA4MYf0P0075ThGq6GvxK2qDW9mks6rHvPYy7Taz0DuDEUeJzLEObmhBzP9jU11tHO
+        P6GyWhnl28oh92SiVR/IsgE9JgA3w5j6R8mZddTZUAX6jcNz+fpy1GPTembo6gQGClzP6pti8YJe
+        JTFwpf1s0Exw0aKcqNNWeC8VzYBklvq5m5e0x+TKNP8jPwFCoA0oK+tQKvE48dTmMF7vv9rOUx4M
+        M49urwRWQaGLm5BY816PJ8X8rQ/YVbUyDTrr1HhXta2Wotis8nqzLlhyTO4BAAD//wMAuV0QSWYD
+        AAA=
+    headers:
+      CF-RAY:
+      - 99d044428f103c35-SJC
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 11 Nov 2025 19:41:22 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - __cf_bm=jp.mByP87tLw_KZOIh7lXZ9UMACecreCMNwHwtJmUvQ-1762890082-1.0.1.1-D76UWkvWlN8e0zlQpgSlSHjrhx3Rkh_r8bz4XKx8kljJt8s9Okre9bo7M62ewJNFK9O9iuHkADMKeAEwlsc4Hg0MsF2vt2Hu1J0xikSInv0;
+        path=/; expires=Tue, 11-Nov-25 20:11:22 GMT; domain=.api.openai.com; HttpOnly;
+        Secure; SameSite=None
+      - _cfuvid=pzTqogdMFPJY2.Yrj49LODdUKbD8UBctCWNyIZVsvK4-1762890082258-0.0.1.1-604800000;
+        path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None
+      Strict-Transport-Security:
+      - max-age=31536000; includeSubDomains; preload
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - nosniff
+      access-control-expose-headers:
+      - X-Request-ID
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - crewai-iuxna1
+      openai-processing-ms:
+      - '460'
+      openai-project:
+      - proj_xitITlrFeen7zjNSzML82h9x
+      openai-version:
+      - '2020-10-01'
+      x-envoy-upstream-service-time:
+      - '478'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-project-tokens:
+      - '150000000'
+      x-ratelimit-limit-requests:
+      - '30000'
+      x-ratelimit-limit-tokens:
+      - '150000000'
+      x-ratelimit-remaining-project-tokens:
+      - '149999817'
+      x-ratelimit-remaining-requests:
+      - '29999'
+      x-ratelimit-remaining-tokens:
+      - '149999820'
+      x-ratelimit-reset-project-tokens:
+      - 0s
+      x-ratelimit-reset-requests:
+      - 2ms
+      x-ratelimit-reset-tokens:
+      - 0s
+      x-request-id:
+      - req_3bda51e6d3e34f8cadcc12551dc29ab0
+    status:
+      code: 200
+      message: OK
+version: 1

lib/crewai/tests/cassettes/test_lite_agent_output_includes_messages.yaml

@@ -0,0 +1,261 @@
+interactions:
+- request:
+    body: '{"messages":[{"role":"system","content":"You are Research Assistant. You
+      are a helpful research assistant who can search for information about the population
+      of Tokyo.\nYour personal goal is: Find information about the population of Tokyo\n\nYou
+      ONLY have access to the following tools, and should NEVER make up tools that
+      are not listed here:\n\nTool Name: search_web\nTool Arguments: {''query'': {''description'':
+      None, ''type'': ''str''}}\nTool Description: Search the web for information
+      about a topic.\n\nIMPORTANT: Use the following format in your response:\n\n```\nThought:
+      you should always think about what to do\nAction: the action to take, only one
+      name of [search_web], just the name, exactly as it''s written.\nAction Input:
+      the input to the action, just a simple JSON object, enclosed in curly braces,
+      using \" to wrap keys and values.\nObservation: the result of the action\n```\n\nOnce
+      all necessary information is gathered, return the following format:\n\n```\nThought:
+      I now know the final answer\nFinal Answer: the final answer to the original
+      input question\n```"},{"role":"user","content":"What is the population of Tokyo?"}],"model":"gpt-4o-mini"}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '1160'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.109.1
+      x-stainless-arch:
+      - arm64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - MacOS
+      x-stainless-package-version:
+      - 1.109.1
+      x-stainless-read-timeout:
+      - '600'
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAAAwAAAP//jJM9b9swEIZ3/YoDZzvwd2xtRTI0HZolcIcqkGnqJLGheCx5Suoa/u+F
+        5A/JTQp00XDPva/ui/sIQOhMxCBUKVlVzgzv5Lf7fDtbmcfRV1M9/l5/Wa/N6/r+7fNydycGjYK2
+        P1DxWXWjqHIGWZM9YuVRMjau49vFZDleLVbzFlSUoWlkhePhjIaVtno4GU1mw9HtcLw8qUvSCoOI
+        4XsEALBvv02dNsNfIobR4BypMARZoIgvSQDCk2kiQoagA0vLYtBBRZbRtqVvNpvEPpVUFyXH8AAW
+        MQMmCCi9KiEnD1wiGMkYGLTNyVeyaRI8FtJn2hZtgiNXmyOgHJ7oZUc3if2kmkh8ckvfcHuOwYN1
+        NcewT8TPGv0uEXEiVO09Wv7IDCajyTQRh8RuNpt+Lx7zOshmnrY2pgektcStSTvF5xM5XOZmqHCe
+        tuEvqci11aFMPcpAtplRYHKipYcI4LndT301cuE8VY5TphdsfzeZnvYjurPo6HR5gkwsTU+1OIMr
+        vzRDltqE3oaFkqrErJN25yDrTFMPRL2u31fzkfexc22L/7HvgFLoGLPUecy0uu64S/PYvJp/pV2m
+        3BYsAvpXrTBljb7ZRIa5rM3xlkXYBcYqzbUt0Duvjwedu3S+GMl8gfP5SkSH6A8AAAD//wMAJGbR
+        +94DAAA=
+    headers:
+      CF-RAY:
+      - 99c98dd3ddb9ce6c-SJC
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 11 Nov 2025 00:08:16 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - __cf_bm=6maCeRS26vR_uzqYdtL7RXY7kzGdvLhWcE2RP2PnZS0-1762819696-1.0.1.1-72zCZZVBiGDdwPDvETKS_fUA4DYCLVyVHDYW2qpSxxAUuWKNPLxQQ1PpeI7YuB9v.y1e3oapeuV5mBjcP4c9_ZbH.ZI14TUNOexPUB6yCaQ;
+        path=/; expires=Tue, 11-Nov-25 00:38:16 GMT; domain=.api.openai.com; HttpOnly;
+        Secure; SameSite=None
+      - _cfuvid=a.XOUFuP.5IthR7ITJrIWIZSWWAkmHU._pM9.qhCnhM-1762819696364-0.0.1.1-604800000;
+        path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None
+      Strict-Transport-Security:
+      - max-age=31536000; includeSubDomains; preload
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - nosniff
+      access-control-expose-headers:
+      - X-Request-ID
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - crewai-iuxna1
+      openai-processing-ms:
+      - '1199'
+      openai-project:
+      - proj_xitITlrFeen7zjNSzML82h9x
+      openai-version:
+      - '2020-10-01'
+      x-envoy-upstream-service-time:
+      - '1351'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-project-tokens:
+      - '150000000'
+      x-ratelimit-limit-requests:
+      - '30000'
+      x-ratelimit-limit-tokens:
+      - '150000000'
+      x-ratelimit-remaining-project-tokens:
+      - '149999735'
+      x-ratelimit-remaining-requests:
+      - '29999'
+      x-ratelimit-remaining-tokens:
+      - '149999735'
+      x-ratelimit-reset-project-tokens:
+      - 0s
+      x-ratelimit-reset-requests:
+      - 2ms
+      x-ratelimit-reset-tokens:
+      - 0s
+      x-request-id:
+      - req_50a8251d98f748bb8e73304a2548b694
+    status:
+      code: 200
+      message: OK
+- request:
+    body: '{"messages":[{"role":"system","content":"You are Research Assistant. You
+      are a helpful research assistant who can search for information about the population
+      of Tokyo.\nYour personal goal is: Find information about the population of Tokyo\n\nYou
+      ONLY have access to the following tools, and should NEVER make up tools that
+      are not listed here:\n\nTool Name: search_web\nTool Arguments: {''query'': {''description'':
+      None, ''type'': ''str''}}\nTool Description: Search the web for information
+      about a topic.\n\nIMPORTANT: Use the following format in your response:\n\n```\nThought:
+      you should always think about what to do\nAction: the action to take, only one
+      name of [search_web], just the name, exactly as it''s written.\nAction Input:
+      the input to the action, just a simple JSON object, enclosed in curly braces,
+      using \" to wrap keys and values.\nObservation: the result of the action\n```\n\nOnce
+      all necessary information is gathered, return the following format:\n\n```\nThought:
+      I now know the final answer\nFinal Answer: the final answer to the original
+      input question\n```"},{"role":"user","content":"What is the population of Tokyo?"},{"role":"assistant","content":"```\nThought:
+      I need to search for the latest information regarding the population of Tokyo.\nAction:
+      search_web\nAction Input: {\"query\":\"current population of Tokyo 2023\"}\n```\nObservation:
+      Tokyo''s population in 2023 was approximately 21 million people in the city
+      proper, and 37 million in the greater metropolitan area."}],"model":"gpt-4o-mini"}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '1521'
+      content-type:
+      - application/json
+      cookie:
+      - __cf_bm=6maCeRS26vR_uzqYdtL7RXY7kzGdvLhWcE2RP2PnZS0-1762819696-1.0.1.1-72zCZZVBiGDdwPDvETKS_fUA4DYCLVyVHDYW2qpSxxAUuWKNPLxQQ1PpeI7YuB9v.y1e3oapeuV5mBjcP4c9_ZbH.ZI14TUNOexPUB6yCaQ;
+        _cfuvid=a.XOUFuP.5IthR7ITJrIWIZSWWAkmHU._pM9.qhCnhM-1762819696364-0.0.1.1-604800000
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.109.1
+      x-stainless-arch:
+      - arm64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - MacOS
+      x-stainless-package-version:
+      - 1.109.1
+      x-stainless-read-timeout:
+      - '600'
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAAAwAAAP//jFPLbtswELz7KxY8W4Es+RHr1ifgQw8F3OZQBxJDrSTWFJcgqSRG4H8v
+        KD+kNCnQCwFyZpazs+TLBIDJkmXARMO9aI2KPvG7z81d8mWf4E/cxN9+PK5SvfkYf08Pe8+mQUEP
+        v1H4i+pGUGsUekn6BAuL3GOoOlstk9vZerle9UBLJaogq42P5hS1UssoiZN5FK+i2e1Z3ZAU6FgG
+        vyYAAC/9GnzqEp9ZBvH0ctKic7xGll1JAMySCieMOyed5/rk+QwK0h51b70oip3eNtTVjc9gA5qe
+        YB8W3yBUUnMFXLsntDv9td996HcZbBsEQ6ZTPLQMVMGW9gcCqSGJkxSkA26MpWfZco/qAMkMWqlU
+        IBskozBQwy1C+gMYSwYtcF1CuroSz4y6j9JCi96SISU918At8pudLopi3JrFqnM8xKs7pUYA15p8
+        77UP9f6MHK8xKqqNpQf3l5RVUkvX5Ba5Ix0ic54M69HjBOC+H1f3agLMWGqNzz3tsb8ujdNTPTa8
+        kgGdX0BPnquRar6cvlMvL9Fzqdxo4Exw0WA5SIfXwbtS0giYjLp+6+a92qfOpa7/p/wACIHGY5kb
+        i6UUrzseaBbDJ/oX7Zpyb5g5tI9SYO4l2jCJEiveqfN3dAfnsc0rqWu0xsrT+65MvljGvFriYrFm
+        k+PkDwAAAP//AwDgLjwY7QMAAA==
+    headers:
+      CF-RAY:
+      - 99c98dde7fc9ce6c-SJC
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 11 Nov 2025 00:08:18 GMT
+      Server:
+      - cloudflare
+      Strict-Transport-Security:
+      - max-age=31536000; includeSubDomains; preload
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - nosniff
+      access-control-expose-headers:
+      - X-Request-ID
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - crewai-iuxna1
+      openai-processing-ms:
+      - '1339'
+      openai-project:
+      - proj_xitITlrFeen7zjNSzML82h9x
+      openai-version:
+      - '2020-10-01'
+      x-envoy-upstream-service-time:
+      - '1523'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-project-tokens:
+      - '150000000'
+      x-ratelimit-limit-requests:
+      - '30000'
+      x-ratelimit-limit-tokens:
+      - '150000000'
+      x-ratelimit-remaining-project-tokens:
+      - '149999657'
+      x-ratelimit-remaining-requests:
+      - '29999'
+      x-ratelimit-remaining-tokens:
+      - '149999657'
+      x-ratelimit-reset-project-tokens:
+      - 0s
+      x-ratelimit-reset-requests:
+      - 2ms
+      x-ratelimit-reset-tokens:
+      - 0s
+      x-request-id:
+      - req_ade054352f8c4dfdba50683755eba41d
+    status:
+      code: 200
+      message: OK
+version: 1

lib/crewai/tests/cassettes/test_llm_call_hooks_can_modify_executor_attributes.yaml

@@ -0,0 +1,262 @@
+interactions:
+- request:
+    body: '{"messages":[{"role":"system","content":"You are Test Agent. Test backstory\nYour
+      personal goal is: Test goal\nYou ONLY have access to the following tools, and
+      should NEVER make up tools that are not listed here:\n\nTool Name: test_tool\nTool
+      Arguments: {}\nTool Description: A test tool.\n\nIMPORTANT: Use the following
+      format in your response:\n\n```\nThought: you should always think about what
+      to do\nAction: the action to take, only one name of [test_tool], just the name,
+      exactly as it''s written.\nAction Input: the input to the action, just a simple
+      JSON object, enclosed in curly braces, using \" to wrap keys and values.\nObservation:
+      the result of the action\n```\n\nOnce all necessary information is gathered,
+      return the following format:\n\n```\nThought: I now know the final answer\nFinal
+      Answer: the final answer to the original input question\n```"},{"role":"user","content":"\nCurrent
+      Task: Use the test tool\n\nThis is the expected criteria for your final answer:
+      Tool result\nyou MUST return the actual complete content as the final answer,
+      not a summary.\n\nBegin! This is VERY important to you, use the tools available
+      and give your best Final Answer, your job depends on it!\n\nThought:"},{"role":"user","content":"Additional
+      context: This is a test modification."}],"model":"gpt-4.1-mini"}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate, zstd
+      connection:
+      - keep-alive
+      content-length:
+      - '1311'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.109.1
+      x-stainless-arch:
+      - arm64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - MacOS
+      x-stainless-package-version:
+      - 1.109.1
+      x-stainless-read-timeout:
+      - '600'
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAAA4xTy47bMAy85ysIneMgcbNp1reizwXaXrpAD83CVmTaViqLWolu2gb590LOw94+
+        gF504HBGw6F0mAAIXYoMhGokq9aZ5KWkz/vdTn14i/dv9h9f19tXi3dtun789H71U0wjg7Y7VHxh
+        zRS1ziBrsidYeZSMUXXxfJWub+fzddoDLZVoIq12nCxni6TVVifpPL1J5stksTzTG9IKg8jgywQA
+        4NCf0agt8bvIYD69VFoMQdYosmsTgPBkYkXIEHRgaVlMB1CRZbS996IoNva+oa5uOIM7CA11poQu
+        IHCDwBg4ZyIDTFAj90WPj532WIK2FflWxqGhIt+DlbbSgLRhj362sS9URLNB6FKCO+s6zuBw3Nii
+        KMb2PFZdkDEj2xkzAqS1xP11fTAPZ+R4jcJQ7Txtw29UUWmrQ5N7lIFsHDswOdGjxwnAQx959yRF
+        4Ty1Lnr+iv116Wp10hPDqgf02XkfgomlGbFuL6wnenmJLLUJo6UJJVWD5UAdNiy7UtMImIym/tPN
+        37RPk2tb/4/8ACiFjrHMncdSq6cTD20e40/4V9s15d6wCOi/aYU5a/RxEyVWsjOn5ynCj8DY5pW2
+        NXrn9emNVi5fqnR9s6jWq1RMjpNfAAAA//8DANALR4WyAwAA
+    headers:
+      CF-RAY:
+      - 99d044470bdeb976-SJC
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 11 Nov 2025 19:41:23 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - __cf_bm=p01_b1BsQgwR2woMBWf1E0gJMDDl7pvqkEVHpHAsMJA-1762890083-1.0.1.1-u8iYLTTx0lmfSR1.CzuuYiHgt03yVVUMsBD8WgExXWm7ts.grUwM1ifj9p6xIz.HElrnQdfDSBD5Lv045aNr61YcB8WW3Vz33W9N0Gn0P3w;
+        path=/; expires=Tue, 11-Nov-25 20:11:23 GMT; domain=.api.openai.com; HttpOnly;
+        Secure; SameSite=None
+      - _cfuvid=2gUmBgxb3VydVYt8.t_P6bY8U_pS.a4KeYpZWDDYM9Q-1762890083295-0.0.1.1-604800000;
+        path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None
+      Strict-Transport-Security:
+      - max-age=31536000; includeSubDomains; preload
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - nosniff
+      access-control-expose-headers:
+      - X-Request-ID
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - crewai-iuxna1
+      openai-processing-ms:
+      - '729'
+      openai-project:
+      - proj_xitITlrFeen7zjNSzML82h9x
+      openai-version:
+      - '2020-10-01'
+      x-envoy-upstream-service-time:
+      - '759'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-project-tokens:
+      - '150000000'
+      x-ratelimit-limit-requests:
+      - '30000'
+      x-ratelimit-limit-tokens:
+      - '150000000'
+      x-ratelimit-remaining-project-tokens:
+      - '149999707'
+      x-ratelimit-remaining-requests:
+      - '29999'
+      x-ratelimit-remaining-tokens:
+      - '149999707'
+      x-ratelimit-reset-project-tokens:
+      - 0s
+      x-ratelimit-reset-requests:
+      - 2ms
+      x-ratelimit-reset-tokens:
+      - 0s
+      x-request-id:
+      - req_70c7033dbc5e4ced80d3fdcbcda2c675
+    status:
+      code: 200
+      message: OK
+- request:
+    body: '{"messages":[{"role":"system","content":"You are Test Agent. Test backstory\nYour
+      personal goal is: Test goal\nYou ONLY have access to the following tools, and
+      should NEVER make up tools that are not listed here:\n\nTool Name: test_tool\nTool
+      Arguments: {}\nTool Description: A test tool.\n\nIMPORTANT: Use the following
+      format in your response:\n\n```\nThought: you should always think about what
+      to do\nAction: the action to take, only one name of [test_tool], just the name,
+      exactly as it''s written.\nAction Input: the input to the action, just a simple
+      JSON object, enclosed in curly braces, using \" to wrap keys and values.\nObservation:
+      the result of the action\n```\n\nOnce all necessary information is gathered,
+      return the following format:\n\n```\nThought: I now know the final answer\nFinal
+      Answer: the final answer to the original input question\n```"},{"role":"user","content":"\nCurrent
+      Task: Use the test tool\n\nThis is the expected criteria for your final answer:
+      Tool result\nyou MUST return the actual complete content as the final answer,
+      not a summary.\n\nBegin! This is VERY important to you, use the tools available
+      and give your best Final Answer, your job depends on it!\n\nThought:"},{"role":"user","content":"Additional
+      context: This is a test modification."},{"role":"assistant","content":"```\nThought:
+      I should use the test_tool to get the required information for the final answer.\nAction:
+      test_tool\nAction Input: {}\n```\nObservation: test result"},{"role":"user","content":"Additional
+      context: This is a test modification."}],"model":"gpt-4.1-mini"}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate, zstd
+      connection:
+      - keep-alive
+      content-length:
+      - '1584'
+      content-type:
+      - application/json
+      cookie:
+      - __cf_bm=p01_b1BsQgwR2woMBWf1E0gJMDDl7pvqkEVHpHAsMJA-1762890083-1.0.1.1-u8iYLTTx0lmfSR1.CzuuYiHgt03yVVUMsBD8WgExXWm7ts.grUwM1ifj9p6xIz.HElrnQdfDSBD5Lv045aNr61YcB8WW3Vz33W9N0Gn0P3w;
+        _cfuvid=2gUmBgxb3VydVYt8.t_P6bY8U_pS.a4KeYpZWDDYM9Q-1762890083295-0.0.1.1-604800000
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.109.1
+      x-stainless-arch:
+      - arm64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - MacOS
+      x-stainless-package-version:
+      - 1.109.1
+      x-stainless-read-timeout:
+      - '600'
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAAAwAAAP//jFLBbtQwEL3nKyyfN1WS3S5pbhRRKCeEkCpgq8RrTxJTxzb2pC1U++/I
+        TrtJoUhcLNlv3vN7M/OQEEKloBWhvGfIB6vSN8xc3b+/FG/P3rX8x9X+y8dfHy7O8fYra88/0VVg
+        mP134PjEOuFmsApQGj3B3AFDCKr5q21RnmVZuY7AYASoQOssppuTPB2klmmRFadptknzzSO9N5KD
+        pxX5lhBCyEM8g1Et4J5WJFs9vQzgPeuAVsciQqgzKrxQ5r30yDTS1QxyoxF09N40zU5/7s3Y9ViR
+        S6LNHbkJB/ZAWqmZIkz7O3A7fRFvr+OtIggeiQM/KtzppmmW+g7a0bMQUo9KLQCmtUEWmhSTXT8i
+        h2MWZTrrzN7/QaWt1NL3tQPmjQ6+PRpLI3pICLmOPRuftYFaZwaLNZobiN+t83LSo/OsZvQIokGm
+        Fqz1dvWCXi0AmVR+0XXKGe9BzNR5RGwU0iyAZJH6bzcvaU/Jpe7+R34GOAeLIGrrQEj+PPFc5iCs
+        8r/Kjl2OhqkHdys51CjBhUkIaNmopv2i/qdHGOpW6g6cdXJastbWG16Up3lbbguaHJLfAAAA//8D
+        AJW0fwtzAwAA
+    headers:
+      CF-RAY:
+      - 99d0444cbd6db976-SJC
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 11 Nov 2025 19:41:23 GMT
+      Server:
+      - cloudflare
+      Strict-Transport-Security:
+      - max-age=31536000; includeSubDomains; preload
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - nosniff
+      access-control-expose-headers:
+      - X-Request-ID
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - crewai-iuxna1
+      openai-processing-ms:
+      - '527'
+      openai-project:
+      - proj_xitITlrFeen7zjNSzML82h9x
+      openai-version:
+      - '2020-10-01'
+      x-envoy-upstream-service-time:
+      - '578'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-project-tokens:
+      - '150000000'
+      x-ratelimit-limit-requests:
+      - '30000'
+      x-ratelimit-limit-tokens:
+      - '150000000'
+      x-ratelimit-remaining-project-tokens:
+      - '149999655'
+      x-ratelimit-remaining-requests:
+      - '29999'
+      x-ratelimit-remaining-tokens:
+      - '149999655'
+      x-ratelimit-reset-project-tokens:
+      - 0s
+      x-ratelimit-reset-requests:
+      - 2ms
+      x-ratelimit-reset-tokens:
+      - 0s
+      x-request-id:
+      - req_6b1d84dcdde643cea5160e155ee624db
+    status:
+      code: 200
+      message: OK
+version: 1

lib/crewai/tests/cassettes/test_llm_call_hooks_error_handling.yaml

@@ -0,0 +1,159 @@
+interactions:
+- request:
+    body: '{"name":"llama3.2:3b"}'
+    headers:
+      accept:
+      - '*/*'
+      accept-encoding:
+      - gzip, deflate, zstd
+      connection:
+      - keep-alive
+      content-length:
+      - '22'
+      content-type:
+      - application/json
+      host:
+      - localhost:11434
+      user-agent:
+      - litellm/1.78.5
+    method: POST
+    uri: http://localhost:11434/api/show
+  response:
+    body:
+      string: '{"error":"model ''llama3.2:3b'' not found"}'
+    headers:
+      Content-Length:
+      - '41'
+      Content-Type:
+      - application/json; charset=utf-8
+      Date:
+      - Tue, 11 Nov 2025 19:41:28 GMT
+    status:
+      code: 404
+      message: Not Found
+- request:
+    body: '{"messages":[{"role":"system","content":"You are Test Agent. Test backstory\nYour
+      personal goal is: Test goal\nTo give my best complete final answer to the task
+      respond using the exact following format:\n\nThought: I now can give a great
+      answer\nFinal Answer: Your final answer must be the great and the most complete
+      as possible, it must be outcome described.\n\nI MUST use these formats, my job
+      depends on it!"},{"role":"user","content":"\nCurrent Task: Say hello\n\nThis
+      is the expected criteria for your final answer: A greeting\nyou MUST return
+      the actual complete content as the final answer, not a summary.\n\nBegin! This
+      is VERY important to you, use the tools available and give your best Final Answer,
+      your job depends on it!\n\nThought:"},{"role":"user","content":"Additional context:
+      This is a test modification."}],"model":"gpt-4.1-mini"}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate, zstd
+      connection:
+      - keep-alive
+      content-length:
+      - '851'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.109.1
+      x-stainless-arch:
+      - arm64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - MacOS
+      x-stainless-package-version:
+      - 1.109.1
+      x-stainless-read-timeout:
+      - '600'
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAAAwAAAP//jFLRbtQwEHzPVyx+vlRJmrte84KOSqgFCSFAqLRUkc/ZJAbHa9lOy6m6
+        f0dOrpe0gMRLpHh2Znd29jECYLJiBTDRci86o+ILTten/ccPFzyp398srz9/2/o3X/PN6btN84kt
+        AoO2P1D4J9aJoM4o9JL0CAuL3GNQTc9W2fo8SdbnA9BRhSrQGuPj/CSNO6llnCXZMk7yOM0P9Jak
+        QMcKuI0AAB6HbxhUV/iLFZAsnl46dI43yIpjEQCzpMIL485J57n2bDGBgrRHPcz+paW+aX0BV6Dp
+        AQTX0Mh7BA5NMABcuwe03/VbqbmCzfBXwCUqRa/g8sC4grEN7KgHTxXfvZ63s1j3jgfPuldqBnCt
+        yfOws8Ho3QHZH60paoylrXtBZbXU0rWlRe5IBxvOk2EDuo8A7oYV9s+2woylzvjS008c2qWrs1GP
+        TdFNaJYdQE+eqxlrTPGlXlmh51K5WQhMcNFiNVGnxHhfSZoB0cz1n9P8TXt0LnXzP/ITIAQaj1Vp
+        LFZSPHc8lVkMl/2vsuOWh4GZQ3svBZZeog1JVFjzXo3nxtzOeezKWuoGrbFyvLnalLnI1su0Xq8y
+        Fu2j3wAAAP//AwDurzwzggMAAA==
+    headers:
+      CF-RAY:
+      - 99d0446e698367ab-SJC
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 11 Nov 2025 19:41:30 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - __cf_bm=b52crfzdOm5rh4aOc2LfM8aQKFI.ZL9WCZXaPBDdG5k-1762890090-1.0.1.1-T2xhtwX0vuEnMIb8NRgP4w3RRn1N1ZwSjuhKBob1vDLDmN7XhCKkoIg3IrlC9KEyhA65IGa5DWsHfmlRKKxqw6sIPA98BSO6E3wsTRspHw4;
+        path=/; expires=Tue, 11-Nov-25 20:11:30 GMT; domain=.api.openai.com; HttpOnly;
+        Secure; SameSite=None
+      - _cfuvid=0TH0Kjp_5t6yhwXKA1wlKBHaczp.TeWhM2A5t6by1sI-1762890090153-0.0.1.1-604800000;
+        path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None
+      Strict-Transport-Security:
+      - max-age=31536000; includeSubDomains; preload
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - nosniff
+      access-control-expose-headers:
+      - X-Request-ID
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - crewai-iuxna1
+      openai-processing-ms:
+      - '1049'
+      openai-project:
+      - proj_xitITlrFeen7zjNSzML82h9x
+      openai-version:
+      - '2020-10-01'
+      x-envoy-upstream-service-time:
+      - '1387'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-project-tokens:
+      - '150000000'
+      x-ratelimit-limit-requests:
+      - '30000'
+      x-ratelimit-limit-tokens:
+      - '150000000'
+      x-ratelimit-remaining-project-tokens:
+      - '149999817'
+      x-ratelimit-remaining-requests:
+      - '29999'
+      x-ratelimit-remaining-tokens:
+      - '149999817'
+      x-ratelimit-reset-project-tokens:
+      - 0s
+      x-ratelimit-reset-requests:
+      - 2ms
+      x-ratelimit-reset-tokens:
+      - 0s
+      x-request-id:
+      - req_4b132b998ed941b5b6a85ddbb36e2b65
+    status:
+      code: 200
+      message: OK
+version: 1

lib/crewai/tests/cassettes/test_llm_call_hooks_with_crew.yaml

@@ -0,0 +1,182 @@
+interactions:
+- request:
+    body: '{"messages":[{"role":"system","content":"You are Researcher. You are a
+      researcher\nYour personal goal is: Research topics\nTo give my best complete
+      final answer to the task respond using the exact following format:\n\nThought:
+      I now can give a great answer\nFinal Answer: Your final answer must be the great
+      and the most complete as possible, it must be outcome described.\n\nI MUST use
+      these formats, my job depends on it!"},{"role":"user","content":"\nCurrent Task:
+      Research AI frameworks\n\nThis is the expected criteria for your final answer:
+      A research summary\nyou MUST return the actual complete content as the final
+      answer, not a summary.\n\nYou MUST follow these instructions: \n - Include specific
+      examples and real-world case studies to enhance the credibility and depth of
+      the article ideas.\n - Incorporate mentions of notable companies, projects,
+      or tools relevant to each topic to provide concrete context.\n - Add diverse
+      viewpoints such as interviews with experts, users, or thought leaders to enrich
+      the narrative and lend authority.\n - Address ethical, social, and emotional
+      considerations explicitly to reflect a balanced and comprehensive analysis.\n
+      - Enhance the descriptions by including implications for future developments
+      and the potential impact on society.\n - Use more engaging and vivid language
+      that draws the reader into each topic''s nuances and importance.\n - Include
+      notes or summaries that contextualize each set of ideas in terms of relevance
+      and potential reader engagement.\n - In future tasks, focus on elaborating initial
+      outlines into more detailed and nuanced article proposals with richer content
+      and insights.\n\nBegin! This is VERY important to you, use the tools available
+      and give your best Final Answer, your job depends on it!\n\nThought:"},{"role":"user","content":"Additional
+      context: This is a test modification."}],"model":"gpt-4.1-mini"}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate, zstd
+      connection:
+      - keep-alive
+      content-length:
+      - '1894'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.109.1
+      x-stainless-arch:
+      - arm64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - MacOS
+      x-stainless-package-version:
+      - 1.109.1
+      x-stainless-read-timeout:
+      - '600'
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAAA2RXTXPbOBK9z6/o8smpkrRJJjPJ6OZy4ownceKKnY+qzaUJNMmOQTQLACUrc5kf
+        sZf9e/NLtrpBycrsRWWTINh4/V6/xz9/Ajhhf7KGE9djccMYlucoX57duvj+fXn/+hrzz8/v3j7f
+        dL/35y9efDlZ6BPSfCNX9k+tnAxjoMIS622XCAvprk+e//r0xW+PH//22G4M4inoY91Yls9WT5YD
+        R14+ffz0l+XjZ8snz+bHe2FH+WQN//4JAOBP+9VCo6f7kzXYZnZloJyxo5P1YRHASZKgV04wZ84F
+        YzlZPNx0EgtFq/22l6nryxouIcoWHEboeEOA0OkBAGPeUvoaLzhigDP7b/01fo0fKBMm18PNNAyY
+        diARzi7hIuFAW0l3WRddxpLET05hWX+NZ6lwy44xwGUsFAJ3FB3B6dnlI2gPTwImgtITNOjuGokE
+        0oLCluwVnjYUZBwolgWMSTbsOXaQS5pcmRJ5oLjhJFFXZMDooYiEDKXHAhSxCQRpLp9SXgDFjiPZ
+        n7paW4mRKUMR8JS5iwsoCTnW+57GIDsY0PUcCQJhilqBdTYDtXpGiiXsVnDbcz68DPKMlecNZeBY
+        BAb8JkmP9XD+BSTCsNxKCh5wHAM7VAS10tKzw2BlZDEkncTMntJ+id6i+5FSAY6Zu77kBXAIUy66
+        JnYKLSdokqAHHkZ0RZtXyPVRgnS7w+5Uditt45MVvN9Q2jBttRVvCQ3xH9q9/hqXcEsxS7oIsoXT
+        1yJdoEdreF8bqA0dJBcYZZwCJpCR4jLLlBxB4CZhUsinTB5aSf8Pb4WexsOV1dH7/v7rvxnaQPes
+        3VWwuZDRATAE2ea5a8oJQJckZzi//pgX8Np+dfPb6495BbVu22/KVvnRqTgq41T4GQLf0bwabhPG
+        HLCQbTRfvO6lSIaeuz5YH4BLhuwwYMOBSwV6lC2llaJ3vbsVZcnpFRX81wU6akTuHq3hTZRtNFB0
+        A7+LOLAzmk7F2o4BuoRjvzjswRla3IiqgeMRAakoBfJhM8J6Rk/N1HV7mI0/rFhhgDYReRmUy/TA
+        0lp3Bq3VwEK/weioio7jXB4l2HBmibZvxDIlDBAwdhN2pGA6ylnfe/ru7fUjw+FsRNcTXH15RwVO
+        zwb8LvHRGm4MuFAhPohsMa/L0zhKKnrsXKpa96fh2FLSQbOAQBtK2JGHZgd1Z/hMDdwoux1lOD37
+        fPOo6j7whlSZS594QxFckMlDnldapVesTJK2wLl0kYtOzluRcMcFTs/f3b5R+ret4nRUcN4f5Ac2
+        w0iplTQoiNaePBK5fgE8YEeVoYXuyxFmC5gKB/5em3woxtpxLqlgRHvs5m43PnBU0oHDdog/zr4c
+        qfVchoYjZXg3Ddc72HLpAaciAxZ24Lk1LAsb7yrbrz8COkdhnkEL6GbwS0Ib/T9Q0Hb8UUQvicYr
+        jt4KPwtjjxcSvI2epyv4oMPwsw3Dc2XrTZk8Ux04vxOG0js1DC3liryNx8sBlcvrY+n2mKEh7WOa
+        bHBy3FvJPMzyLhcaMjgcrT3SAmEKO3VFRwk86UjZH3tM+jIbqCMW7SzIVJwMlBeQJ9cDZht6+9NV
+        f7DWesaGFM9EhaOMWHo1BeyiZK5dOZuKRBlkyvCJenaB8vpY3T3hhsMOaNCxVgl9SznUjn9sKOkB
+        66jPFFpjsRa7b8RCnaMkbqZqClJdp/CgxHQm2uWAd3sVRTLpRiomfx7UeqvcrWBNCNGA3YtpPUtz
+        nhRtwskfgTjbJRb44/pKUocRznvMtKgere9VLVOy1w+iPXZuSjplS2/phL1SsZ390cq4MdXAB3JV
+        kRLX/1TGu9s3R3OMYq/t9darYw1Ke4RImcWjhe9HwAJmeJwMwxT3Lr23l/2Qy7X2TDgEyhWsGxsF
+        Wjnsg9TahKgsPYiJlGVSiHX4B/PcPev0Paakg1w0NWwkTHqPv+vahh/s3KepA8/ZyYZSdfWfV/Cq
+        5gRjTKYEn5i2o3Asqi6NaOb5Jg8+jkyzbNMKLoiXF8TwlheAkEidijzcFIytJKu/pZwlWXmEmo/u
+        HReqRtzIVAx4T4M4nR/fK8bSqiJrbtswqhWnZZuYog+7H7JSMxVAcDhVZdqOesiWzer2NFOw9NaY
+        ZDRtFEpjojJb8QqubVjpJnpALEcx0E777tPly8sz1VuPmb/XhBppTitH6bWIdlCGQbxSlQZKZqw9
+        Jr/FyuLaX0lzE/UTYFCrnXJewas55J1dqqmKw0IZMGR5iBKqXUcp7kMt5t1xwJG2iq6dbJcZgsGe
+        pHt0lBotrWHMmkNbiFJAp2g7haDJNqpHGkueHepZwI0lzmpFrwaZk8f5DwF0/TVqTkg4sj/OBHNH
+        j3BSqj+0nbzettGrDVHYrbN6bJ4/I8hD4nyX//7rP1o64DCGg/r1W4A36HZASbJd0Dq/SaO8HwPW
+        OlZwIUlB0M+1BQRMFkPIEgP5PVbNxKHG4p4yHZc94A449pS4MndM9G3yFh5oaMj76saHBOKx4Ooh
+        KIN9GGrntTqltSJhX1x+KjtlD2tphplNnRE1vFQZt8gpUs7QkkapY6v5RxauZuMwefDiJstyB++a
+        fcQWqhK6OmzofgzIcZ9OTX0r6zqVHQxTLtBgsOHIMcqmbmgMTtRNYZ5/NrOqM3L0vGE/YYBUI7CF
+        twN3thTCsiHLMpRHUn4FxRcyxVwDVcsU/CzC/uD3Rs5fVnAxWch/+fBRWN9Rq7YsoF84ysu3Ijau
+        W0lbTH4B/wMAAP//jFjNbtswDL73KQSfWiAo0Kwbgt2GXVZgP6fdVgSKTNtcZUnQT7ocCuwh9oR7
+        koGkYjtZBuxMR7Ep8vs7nUdaTULQfaXDqTFqLDYjrbOd1dr1QrqSLKs6rVoJXVr0Kvse8gDxZnWU
+        UDRg577mmqj+08cb+SXbbogKHMT+MMlGc/SSIfoRaWvTqGOGuJqYkV6GZAvBhjAQupZcHwJtTBf9
+        qKAtsi2qpKo5E10E79/stEJgGFv4aG3V6B1mH2sHlbFIH6TMoF0PasSMvdAwacglcn4J4OilXKs+
+        VJNB5oYbbquXROJqndkXZ0/Xw7Y5ELbUj1rgG48c+UeeUbGCA1TPStJOXK20q/PFtW8XnWR9ShdV
+        ejoNWjWUUbsT8FnN6HP03HvsUYZfTIWxJeGeFsUM2lpwPbuCb+49xSs/Mg39Z59BIPFSDIDVHB5U
+        BAt77TJ39t2DCksyWqngLZrDqJ+mjIKQhzkMEsuEsrNobtUD4Sz7Dc38FWGgPdqDSk6HNPhcCcMW
+        gy0Ty+CfzxaB/c7Jhg9o2auNgbfaRMzckgidrWrOu2WuQAPcdWwx+GZqt4TYDan4JCp+GVeQ1iB8
+        fQIRztkHNBTO6MmYGpI/O8sa0fgSa0W5IhqOFU6J5GmXiYakA4IUc7jBHkB2XNQjaR5mVnnXSwBB
+        RPmdgJAP5yYwTP7++SsPcOBnqhzMh6NzDFZnkpVJpUGHGsEQuJMH8pSddWfB1q366lqIlNy1c2Rz
+        OqDz1MlITOty5E9MClJisya2Y9BMHtXuoFPP+lAVBIPfkeclWbIHtQMHEtjVqSM+YoFMm3q7zBRJ
+        OyRNwaYr1i4K2jkv1MNp5mOtvEz5pfV9iH6Xzn7adOgwDdsIOnlHWWXKPjRcfblS6pFz0nISfTYy
+        o9vsn4D/7tV9zUmbOZ+dq5vNplazz9rOhbv1+lg5OXHbQtZo0yJrbQyFFe382zmYZRJYFK4W3/33
+        +1w6W74dXf8/x88FYyBkaLezWbj0WAQav389NvWZX7ipnmebESLdRQudLlZS5UaM87ZD15OoRomW
+        u7C9N+vN67tu82bdXL1c/QEAAP//AwBbY8c8aRcAAA==
+    headers:
+      CF-RAY:
+      - 99d0447958ce36e8-SJC
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 11 Nov 2025 19:41:45 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - __cf_bm=dSe1gQEFfPpE4AOsFi3S3RQkzPCQnV1.Ywe__K7cSSU-1762890105-1.0.1.1-I1CSTO8ri4tjbaHdIHQ9YP9c2pa.y9WwMQFRaUztT95T_OAe5V0ndTFN4pO1RiCXh15TUpWmBxRdxIWjcYDMqrDIvKWInLO5aavGFWZ1rys;
+        path=/; expires=Tue, 11-Nov-25 20:11:45 GMT; domain=.api.openai.com; HttpOnly;
+        Secure; SameSite=None
+      - _cfuvid=LMf_4EPFZGfTiqcjmjEk7WxOTuX2ukd3Cs_R8170wJ4-1762890105804-0.0.1.1-604800000;
+        path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None
+      Strict-Transport-Security:
+      - max-age=31536000; includeSubDomains; preload
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - nosniff
+      access-control-expose-headers:
+      - X-Request-ID
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - crewai-iuxna1
+      openai-processing-ms:
+      - '15065'
+      openai-project:
+      - proj_xitITlrFeen7zjNSzML82h9x
+      openai-version:
+      - '2020-10-01'
+      x-envoy-upstream-service-time:
+      - '15254'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-project-tokens:
+      - '150000000'
+      x-ratelimit-limit-requests:
+      - '30000'
+      x-ratelimit-limit-tokens:
+      - '150000000'
+      x-ratelimit-remaining-project-tokens:
+      - '149999560'
+      x-ratelimit-remaining-requests:
+      - '29999'
+      x-ratelimit-remaining-tokens:
+      - '149999560'
+      x-ratelimit-reset-project-tokens:
+      - 0s
+      x-ratelimit-reset-requests:
+      - 2ms
+      x-ratelimit-reset-tokens:
+      - 0s
+      x-request-id:
+      - req_c49c9fba20ff4f05903eff3c78797ce1
+    status:
+      code: 200
+      message: OK
+version: 1

lib/crewai/tests/cassettes/test_task_output_includes_messages.yaml

@@ -0,0 +1,423 @@
+interactions:
+- request:
+    body: '{"messages":[{"role":"system","content":"You are Researcher. You''re an
+      expert researcher, specialized in technology, software engineering, AI and startups.
+      You work as a freelancer and is now working on doing research and analysis for
+      a new customer.\nYour personal goal is: Make the best research and analysis
+      on content about AI and AI agents\nTo give my best complete final answer to
+      the task respond using the exact following format:\n\nThought: I now can give
+      a great answer\nFinal Answer: Your final answer must be the great and the most
+      complete as possible, it must be outcome described.\n\nI MUST use these formats,
+      my job depends on it!"},{"role":"user","content":"\nCurrent Task: Give me a
+      list of 3 interesting ideas about AI.\n\nThis is the expected criteria for your
+      final answer: Bullet point list of 3 ideas.\nyou MUST return the actual complete
+      content as the final answer, not a summary.\n\nYou MUST follow these instructions:
+      \n - Include specific examples and real-world case studies to enhance the credibility
+      and depth of the article ideas.\n - Incorporate mentions of notable companies,
+      projects, or tools relevant to each topic to provide concrete context.\n - Add
+      diverse viewpoints such as interviews with experts, users, or thought leaders
+      to enrich the narrative and lend authority.\n - Address ethical, social, and
+      emotional considerations explicitly to reflect a balanced and comprehensive
+      analysis.\n - Enhance the descriptions by including implications for future
+      developments and the potential impact on society.\n - Use more engaging and
+      vivid language that draws the reader into each topic''s nuances and importance.\n
+      - Include notes or summaries that contextualize each set of ideas in terms of
+      relevance and potential reader engagement.\n - In future tasks, focus on elaborating
+      initial outlines into more detailed and nuanced article proposals with richer
+      content and insights.\n\nBegin! This is VERY important to you, use the tools
+      available and give your best Final Answer, your job depends on it!\n\nThought:"}],"model":"gpt-4.1-mini"}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '2076'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.109.1
+      x-stainless-arch:
+      - arm64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - MacOS
+      x-stainless-package-version:
+      - 1.109.1
+      x-stainless-read-timeout:
+      - '600'
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAAA1xXS44kxw3d6xREbwwMqgsaWWPJvSvNT21roIE0kAx5NswIViWnI4MpMiKra7TR
+        IbTxSbz3UXQSgxFZ1S1tGuiMH/n43iPrl08Arjhe3cBVGLGEaU7Xz/HHL3/YfTz+9GJ69sPXL8sr
+        e/bT9JMefv4Ql39dbfyEDB8olPOpbZBpTlRYcl8OSljIb336xd8++/Lp3//6xbO2MEmk5McOc7n+
+        fPv0euLM1599+tmz608/v376+Xp8FA5kVzfw708AAH5pfz3QHOn+6gY+3Zy/TGSGB7q6uWwCuFJJ
+        /uUKzdgK5nK1eVgMkgvlFvu7UephLDdwC1mOEDDDgRcChIMnAJjtSPo+v+KMCXbtv5v3+X2+hidP
+        drfXL5QXyvCW1CRj4o8U4WvCVMaASjfwHS2SqsPCHzkf4C0Wplzg21qCTGTwblSPAN4qRQ7F395l
+        TKfCwZ48eZ8B3o1swJEQ6H5OomQwyhF2t8AGRTHbXnTyy8fLwzCcgDIOqX3mw5hOwDnywrGuURbP
+        b/JY5oTZYECjCJJhXkOMWBAwR5gfQmvFsy28EgXODmygDXjtMTMZJL4juP3qDfyIxSSvUMCIC0Gi
+        hRQPFD30IoCe5keCyW/HBEpBNNoGDpRl4mCb9npInNt6UcZkfrIgJ1EvViCFMpLi7K/XzD9XSiew
+        ysVTFCAM4zmjLbwgmt9wjr//+h/zKOxkhSYY0cBGOWaYVSY2As6XrPMB7jhmcgA/VD0BoabTBgwX
+        X0u8kEFZqzirYEeKcyFdKHvpt3Db/mM6GhzZAXmo1KyyJzN2+ljHu4droLQQJhikjEC5jNUYbYK9
+        KOxuWw6zOJEZU4dKHJBsgIPUArPyguHUlloxjUJVLqdNpwQfxpYelbEBHDnRNKF59iPm2MhjlI3X
+        jJxn2BP6XgJjchyK09NG3hcIUlMEpVgDQWSbUbl4YfzCh4wxBDKDoRbAZALKdmdA9xhIB2whcaaf
+        najlBLzvfBFHRwlqpoVyOvkDRXmoheIWXk5SGoQe0gXAgTLtucBeZYJRZmpY8DSrLOTElkMW4x7L
+        5Hj0iOh+JmXKwQ/cM5UTyEIKWItMbmsQKbDX7HrCO86HLbyqpSr53YlDA8nTDqlGgt3t9SxHUoqw
+        sJaKaYUDLvbUK6+E6brw5ELLXEQdi0aYI6HikAgGFi+JqG1WtvoeBJtQC+kGJlECJZslm5ftEfAU
+        ZGV8GfFcLrovlCMk3lPLO7ioO2nOJZB9Xz4kGRzhbfekIjMHNyGlRAvm0g5RPuChxWTABYrUMLpl
+        1QkzHCml64HacgGEfc0R3YQwNX/oPOa8cCG/FyNpk3zwbGJXu2tLHWSCAZObAAxUjkQZCoUxS5JD
+        T6Axu9GvmQxn2l68uxbJMkltRrA7NL5whudui47bbY7VCUZ2Ay/vZ8zRo/5KPGL/6qjstGzgTTUO
+        3au+L6KnQsmV82fzjpSWJoUi/iL2F5thfjtTXgX9YvfNN//778um8YXNqYL+yD/qHUUKd+2ZR/v9
+        +yD3bf/kgTQzFpes5B5URtWe0oEyKRZRA6vB2eeRvKj5QL75D70knHGYVVyuZF51MnpQYxgxJcoH
+        8pORu/4gSye/7F0uo6iNPHd76lc6o4YTBEkJB9Eu+O6KjSOoha0YtBYTaaYcKZd0OoffousdfAvf
+        uWKOoilCQCOwUmN3nC69H1Ezaa/RKmun2+XJ3e117C28ozerxBo8gxays+11RY2MGeY6JLbRz+5u
+        r9do3EaEinpHmFHdDPrGAJEGLOSwtRkD0krnVnOnQEsUvqM933nTj+IebKHapcNTHp3f9lCOUZQ/
+        SrYNHEdOBHZHs88KcBTV0+r8HnbkPnd4ITqwdPZIB0J7z+kN59JFPsjQjDthoDYbOK/Wgmzh5aVR
+        tCBbmfcSqvnYEGQ+qVvoBuSYqZV9cwHRqeBvhNVP3BIb1BQ98jt73FIe5BFpkuA1/3hpG24GZzA6
+        D5t546lbd5Bpksj7k4fdKPso7+jFb2lzXqTpEZ0vDvFffABxLCX//utvR8nuNh7+Hi1wbpYOC6lV
+        O4PONnWbefSABcmZQrl0hKKUo9u7H5jdtEzmka00B2vD0IMUXJrNm6s/750hQqipVMXUSX9fHj/p
+        TeBcvHTy1kt7zs1etQAXo7TfPjKhgHPhBR+baxtUyDwUzq1W+2orb/5kp77YqWQzK3ul93vS3oCU
+        w/jIaxrGWRa8aIldxlxOFws+02l3C6+9vWan+g18VTk1r33nfjSjUi4b2IUgNZfWA79vTcw6OeGd
+        VitH0TKeVswfWW/vURijNg9rKVR1ckEmiu2KveJEjYRA2ap2gUP0fiRzkwEmPmR77FILpkq2AZrm
+        Ea0P9+UScDhtnK89Yk5t5upcYs1ktoXnf5yZX4scEl0G1Lb5DQcVk33p8zOZZ882dtKsvW0QbENz
+        dwPOXLgV4MHie7dowmj9+DIcOJQtzznJafqznVqgjMry4KXOPx+c1Fr784Fo4ParYY8u3TbBH3Jr
+        BOtobVB9fThBwiOQT5DdWDZA9+Sz0p77uru3rbLsDv8HfJ4nwjZAw+52A4p97DEJTD47YEKdVvOz
+        qgtx6oNBm33ZgvK0anjr3Zz03Hvf8ZS5wGsatLbd/3SJPlc87kXbiLiw5+6TrJN1JjUfkhrEkhsC
+        7ZwVraEL1X8ouL7degaKsUvr8nvDf9jERUJvZfvW50KqbVqLZHzI6zB4qOkccpfKZd7utJ5VhpXT
+        k2grwFpZPs9tzSrdVVbnquaaX8X8fwAAAP//jFjNbtwgEL7vUyBfcmkr7SZt95pjpLxCZBF7sFEw
+        EMCtcth3j74BL3jbSj2PjT3AfH+squh9ZfwrhN2Iok3jxr3cp0B3UQBLjLn5++k6xs1JjhrfBjXL
+        N5qd2SSdh72xgO4wafbOW7M7LZ+5NGHIBbg3b3sdtcQ3e7VFdXNvi056khv7KZKBRaospvDxSSw6
+        rpGgMW4p75t4do5pXM4kR+64zh6jgVMZNfOFyghWTsuFD8GwjamsGhToTSFpdfUGIKxXQgYgvP7l
+        kjRfduhTrEv2PHGWMA+vwcnRZCzOpgnZyQI7v5PkMQVnJ+YDpBJAe0auDfKLT6SxkQsYJffVO1Pu
+        uV68HFKm6p0oL/6WmW7FuWLYZ+kzC6hMer9xS1r6oIUdUBRB4gaB5GwmuUXbzR6AHNqcJpBao0RY
+        ZFdjmoK01qW8kUiIXkrlcs2EjJswHPHm1Q7kGOc+kIzOIv+JyfmOq5eDEC+cPa27OKmDy/KpT+6N
+        +HP355I9dTXzqtWfD/elmnCotXA8nrbKbsV+JOQZscmvukEOM4313Rp2Qa64pnBo+v7zf/62du5d
+        2+l/lq+FAdqIxn6LRdqe62OBEAr+67HrPvMPdxGRyEB90hRwFiMpuZqc1HUZKnuFiQ8+6BzXKd8/
+        DKfz96M6/zh1h8vhEwAA//8DAJPMJFq9FAAA
+    headers:
+      CF-RAY:
+      - 99c98602dfefcf4d-SJC
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 11 Nov 2025 00:03:08 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - __cf_bm=ObqPLq12_9tJ06.V1RkHCM6FH_YGcLoC2ykIFBEawa8-1762819388-1.0.1.1-l7PJTVbZ1vCcKdeOe8GQVuFL59SCk0xhO_dMFY2wuH5Ybd1hhM_Xcv_QivXVhZlBGlRgRAgG631P99JOs_IYAYcNFJReE.3NpPl34VfPVeQ;
+        path=/; expires=Tue, 11-Nov-25 00:33:08 GMT; domain=.api.openai.com; HttpOnly;
+        Secure; SameSite=None
+      - _cfuvid=kdn.HizdlSPG7cBu_zv1ZPcu0jMwDQIA4H9YvMXu6a0-1762819388587-0.0.1.1-604800000;
+        path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None
+      Strict-Transport-Security:
+      - max-age=31536000; includeSubDomains; preload
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - nosniff
+      access-control-expose-headers:
+      - X-Request-ID
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - crewai-iuxna1
+      openai-processing-ms:
+      - '13504'
+      openai-project:
+      - proj_xitITlrFeen7zjNSzML82h9x
+      openai-version:
+      - '2020-10-01'
+      x-envoy-upstream-service-time:
+      - '13638'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-project-tokens:
+      - '150000000'
+      x-ratelimit-limit-requests:
+      - '30000'
+      x-ratelimit-limit-tokens:
+      - '150000000'
+      x-ratelimit-remaining-project-tokens:
+      - '149999507'
+      x-ratelimit-remaining-requests:
+      - '29999'
+      x-ratelimit-remaining-tokens:
+      - '149999507'
+      x-ratelimit-reset-project-tokens:
+      - 0s
+      x-ratelimit-reset-requests:
+      - 2ms
+      x-ratelimit-reset-tokens:
+      - 0s
+      x-request-id:
+      - req_2de40e1beb5f42ea896664df36e8ce8f
+    status:
+      code: 200
+      message: OK
+- request:
+    body: "{\"messages\":[{\"role\":\"system\",\"content\":\"You are Researcher. You're
+      an expert researcher, specialized in technology, software engineering, AI and
+      startups. You work as a freelancer and is now working on doing research and
+      analysis for a new customer.\\nYour personal goal is: Make the best research
+      and analysis on content about AI and AI agents\\nTo give my best complete final
+      answer to the task respond using the exact following format:\\n\\nThought: I
+      now can give a great answer\\nFinal Answer: Your final answer must be the great
+      and the most complete as possible, it must be outcome described.\\n\\nI MUST
+      use these formats, my job depends on it!\"},{\"role\":\"user\",\"content\":\"\\nCurrent
+      Task: Summarize the ideas from the previous task.\\n\\nThis is the expected
+      criteria for your final answer: A summary of the ideas.\\nyou MUST return the
+      actual complete content as the final answer, not a summary.\\n\\nThis is the
+      context you're working with:\\n- **AI-Driven Personalized Healthcare: Revolutionizing
+      Patient Outcomes Through Predictive Analytics**\\n  This idea explores how AI
+      is transforming healthcare by enabling highly individualized treatment plans
+      based on patient data and predictive models. For instance, companies like IBM
+      Watson Health have leveraged AI to analyze medical records, genomics, and clinical
+      trials to tailor cancer therapies uniquely suited to each patient. DeepMind\u2019s
+      AI system has shown promise in predicting kidney injury early, saving lives
+      through proactive intervention. Interviews with healthcare professionals and
+      patients reveal both enthusiasm for AI\u2019s potential and concerns about privacy
+      and data security, highlighting ethical dilemmas in handling sensitive information.
+      Socially, this shift could reduce disparities in healthcare access but also
+      risks exacerbating inequality if AI tools are unevenly distributed. Emotionally,
+      patients benefit from hope and improved prognosis but might also experience
+      anxiety over automated decision-making. Future implications include AI-powered
+      virtual health assistants and real-time monitoring with wearable biosensors,
+      promising a smarter, more responsive healthcare ecosystem that could extend
+      life expectancy and quality of life globally. This topic is relevant and engaging
+      as it touches human well-being at a fundamental level and invites readers to
+      consider the intricate balance between technology and ethics in medicine.\\n\\n-
+      **Autonomous AI Agents in Creative Industries: Expanding Boundaries of Art,
+      Music, and Storytelling**\\n  This idea delves into AI agents like OpenAI\u2019s
+      DALL\xB7E for visual art, Jukedeck and OpenAI\u2019s Jukebox for music composition,
+      and narrative generators such as AI Dungeon, transforming creative processes.
+      These AI tools challenge traditional notions of authorship and creativity by
+      collaborating with human artists or independently generating content. Real-world
+      case studies include Warner Music experimenting with AI-driven music production
+      and the Guardian publishing AI-generated poetry, sparking public debate. Thought
+      leaders like AI artist Refik Anadol discuss how AI enhances creative horizons,
+      while skeptics worry about the dilution of human emotional expression and potential
+      job displacement for artists. Ethical discussions focus on copyright, ownership,
+      and the authenticity of AI-produced works. Socially, AI agents democratize access
+      to creative tools but may also commodify art. The emotional dimension involves
+      audiences' reception\u2014wonder and fascination versus skepticism and emotional
+      disconnect. Future trends anticipate sophisticated AI collaborators that understand
+      cultural context and emotions, potentially redefining art itself. This idea
+      captivates readers interested in the fusion of technology and the human spirit,
+      offering a rich narrative on innovation and identity.\\n\\n- **Ethical AI Governance:
+      Building Transparent, Accountable Systems for a Trustworthy Future**\\n  This
+      topic addresses the urgent need for frameworks ensuring AI development aligns
+      with human values, emphasizing transparency, accountability, and fairness. Companies
+      like Google DeepMind and Microsoft have established AI ethics boards, while
+      initiatives such as OpenAI commit to responsible AI deployment. Real-world scenarios
+      include controversies over biased facial recognition systems used by law enforcement,
+      exemplified by cases involving companies like Clearview AI, raising societal
+      alarm about surveillance and discrimination. Experts like Timnit Gebru and Kate
+      Crawford provide critical perspectives on bias and structural injustice embedded
+      in AI systems, advocating for inclusive design and regulation. Ethically, this
+      topic probes the moral responsibility of creators versus users and the consequences
+      of autonomous AI decisions. Socially, there's a call for inclusive governance
+      involving diverse stakeholders to prevent marginalization. Emotionally, public
+      trust hinges on transparent communication and mitigation of fears related to
+      AI misuse or job displacement. Looking ahead, the establishment of international
+      AI regulatory standards and ethical certifications may become pivotal, ensuring
+      AI benefits are shared broadly and risks minimized. This topic strongly resonates
+      with readers concerned about the socio-political impact of AI and invites active
+      discourse on shaping a future where technology empowers rather than undermines
+      humanity.\\n\\nYou MUST follow these instructions: \\n - Include specific examples
+      and real-world case studies to enhance the credibility and depth of the article
+      ideas.\\n - Incorporate mentions of notable companies, projects, or tools relevant
+      to each topic to provide concrete context.\\n - Add diverse viewpoints such
+      as interviews with experts, users, or thought leaders to enrich the narrative
+      and lend authority.\\n - Address ethical, social, and emotional considerations
+      explicitly to reflect a balanced and comprehensive analysis.\\n - Enhance the
+      descriptions by including implications for future developments and the potential
+      impact on society.\\n - Use more engaging and vivid language that draws the
+      reader into each topic's nuances and importance.\\n - Include notes or summaries
+      that contextualize each set of ideas in terms of relevance and potential reader
+      engagement.\\n - In future tasks, focus on elaborating initial outlines into
+      more detailed and nuanced article proposals with richer content and insights.\\n\\nBegin!
+      This is VERY important to you, use the tools available and give your best Final
+      Answer, your job depends on it!\\n\\nThought:\"}],\"model\":\"gpt-4.1-mini\"}"
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '6552'
+      content-type:
+      - application/json
+      cookie:
+      - __cf_bm=ObqPLq12_9tJ06.V1RkHCM6FH_YGcLoC2ykIFBEawa8-1762819388-1.0.1.1-l7PJTVbZ1vCcKdeOe8GQVuFL59SCk0xhO_dMFY2wuH5Ybd1hhM_Xcv_QivXVhZlBGlRgRAgG631P99JOs_IYAYcNFJReE.3NpPl34VfPVeQ;
+        _cfuvid=kdn.HizdlSPG7cBu_zv1ZPcu0jMwDQIA4H9YvMXu6a0-1762819388587-0.0.1.1-604800000
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.109.1
+      x-stainless-arch:
+      - arm64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - MacOS
+      x-stainless-package-version:
+      - 1.109.1
+      x-stainless-read-timeout:
+      - '600'
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAAA1xXzY4bxxG++ykKexRIQlKcRN7b2pIcBrItSwIUIL4Ue4ozJfZ0tau6yR35oofw
+        JU+Sex5FTxJUz3BJ6bLAcqa66+f7qfnjG4Ab7m5u4SYMWMKY4/oHfP/sw1v99WM3vvzX8x9//3mr
+        rx4f3te85WflZuURsvtAoZyjNkHGHKmwpPlxUMJCfuqTv//t6bMn3/3l2XftwSgdRQ/rc1l/u3my
+        Hjnx+unjp39dP/52/eTbJXwQDmQ3t/DvbwAA/mh/PdHU0f3NLTxenX8ZyQx7url9eAngRiX6Lzdo
+        xlYwzUkvD4OkQqnl/m6Q2g/lFraQ5AQBE/R8JEDovQDAZCdSgN/SS04Y4a79f+s//JYePbrbrp8r
+        HynBa1KThJE/Ugf/IIxlCKh0C2/oKLF6Y/gjpx5eY2FKBX6pJchIBu8G9RzgtVLHofjtdwnjVDjY
+        o0d+07uBDbgjhECpkBpIgjIQFMVke9ERW1gWz1X2cLcFTjA8ZLGC00BKkC9X4PkKoIS7SDBMmXSd
+        r8so3oLRk80Rk0FBjqL+QNr1nIpywELQkT8zv5tTx0fuKkbIS6kdFtzAa5ZEpN4DBwsmJoPIB4Lt
+        9z/Beywmaekc1MKeghdSBIz3BcrSpiNagdHrwAhKQbSzFfSUZPRq/C6jYivA1EGInNqLRRkj7D25
+        1NsKguK+eCo7siwH8skHUi9LMXtmZfDxR+6Tty2wUZzgxGUAPBf2+dN/DGri36u3VvYcaQNveeSI
+        GqcVPCfKP3Hq2nvYHf2KzmuyyQqNBgMevXejJCvqdIHIe1obHluXMOOOI5cJdhNgCNXfiRPsRSmg
+        tfwx1EJw4C7RBJw+VPXkcSDsfBo2jbnIaIA5E3rzV4AxysljsxKNucHh3FB2fB0pOV43sE3G/VD2
+        9fyA6WRzEy7ggqwYCnuEQ9PbvvTHYOB+iH4EIDRIJFRtYP386c/TwJFgxDQBjTvF4PNuvcoqIxt5
+        ocBjVjlSB3ImjN8wSKZVmxaB52DcJ95zwFQgiI8yGeBO6ow+yMpHDFOLpTK0Wq3QCbWzgXNrFSXj
+        r5qxcMt70Uh4Di3+riSoqSO1IOppwYgfRMEkMBWM0NEOC902qmRxxXEMzvQsAjvlrqfrRmIIZAY9
+        ZoMjqVVrscp2mOFYE/3uXezYivKuqcrDgRINRpzgJGqUgO55RkjHllG5MNkGXoziQRgdnw9jcoXs
+        wPEOQcVMBTv7/OnPHSXac2nH7FVG2FEppD6fPokts/hCM2a5mahAr5hz9NAGmJoIjUCOpIC1yNjw
+        flV95yRjSXZpVpzAanbxaSkMdcQEH2rXuyht4JXIoaUm6oNseABKx3YMdbCvparLVIi1I4O77bpJ
+        JHVwZC3eyfl+eLCJuaIToTZR3LE4LEQNOop8nOVLCeO68EgwSuIiM61cOWLXOAk2ohbSFYyi5IBM
+        FL4ql4LMMrCBtzUMwCnJsWHtgv8iQGlw2YA+yg5j0weg+0yhYFrw7JBwkZB9e7yCEVtbiiO2SObQ
+        2JuagilFOjpLGhMuaAAlH6I/MOACRWoYaAag49tPn/t/ohjXO2qFusRijNaYipDqLHE7jC3pHZUT
+        UYJQG4bW5IAvFIYkUfo5+zPZGrVss/hqLZJklOpDg7u+oZQT/OCO5BTdpq46B8hu4cV9xqbr8L3U
+        1GFTQGeFlhX8VI3DbAZvi+hUKDomr4y1yUUu3tXYiDzIqSH0kgDOCfjYlGzA3OT5nMueKboHhQFj
+        pNSfO4O14bSNQrHjudWQZB6y7M9H+PDmgDKIuh5t4F3jszky0OCXTGnRxud3r179778v3PHI/aCZ
+        6VwUHNkc1Khlpmuh+4Zyx1N2T1wk13vS4sRaVu7vxbVuMeR/1gN1FA4tq6u7/fed3F91J05zEQSi
+        3LcVyST1toGfz0oPrSVnr7/bwvOaepIEerUZEdjVdJrfnV2qmxKOPsNmQTivLzlKgY6OFCXPG8pC
+        7N0Ed9sNvHGKnkRjB02FwsIsjrE2r30giA2+XSwaAe9RE+mMmlayc03Zr8AI1eii31mlq4F87Fr8
+        rjJMS2uLYjjMUvJuIPixonaMqR24k9hBrrtzTvOB6/M4O8hCRacVuGo3HrvuxGmJcTkPUtXI7Xkf
+        62Irx7YvP/QYtbAVeEN7Pvg62UkEGvOA5r12hN9tvbbG4DOQB1H+KMlW8054kdz5NGt7n6+cgTxM
+        0rIoNF0a+QKw4HYTDALOFtXMSylyUwVJfrlbFal0dFGhRgA/MpwZ4d4VfTF4yNH3LDJr77ufLYY8
+        e61T1CUAguRJfe9YgZx8LRk4rx449nDFLIu8n5xjXwzhJHqwB0bTxU09JEYKZ15l0jLBXnGkFrOB
+        txJ49tcykNHFnH3RCw69j3TF/BVIptSALu4zrqQ7N2D3WW984DwDZVfLF9YYZByl4/3UBEcdxEVg
+        RLP1gs22NOVavjZ+rB1TcrwoenVNLGakUwrtuBP5PuDqn+RIcUnYKeQL+YGyJ2bj3NO2OzVqXM0y
+        MqVld3o5G/EVX50cS2nNoJXQOPVu+JIH73Voc7jbQpAYcSeKxdvTluJI85dGIc1KbS6hxlIVI7SP
+        u/uv/G1xptUX/bss0SfHJ/tnBc4FLpqGWpbFb7bRgL4tN6Ap+YRs/gbq66w83q59tYXVV0bXNiB/
+        OvPJMiuXlS/gtjgEwh4tcJqV6WFNPg+h1WoUzopx2RZW/mWYSkOS1zzn0Pot+4W5HHy6OvNmsdgX
+        Zfg/AAAA//+MWctu5DYQvPsriDnLRmxsAiM3Z5E1jE1O8XUx4FAtDdcUKfMxGwfwvwfVTUmciQ85
+        GQZHlNiP6qoid87Dk3oEKfMI0K/qt2KFxDyj0WcdyedOPRgTis8c+b+qeJGR/xxLyhX8JM3taGUc
+        AF8+0oRDnChlO3IA+VTTTPWc2C2GQ0m5aSZFPhWmXA9PZ2jP2ECzC2/yL8s0DjJzFYnySbtC2wzN
+        64EMQrWciAWWhG7QNnpK6Ub9QZqDgBQqju4qVh9DGB2t2o4f/NOCNochi6KbRelK+QqvUYegWagK
+        QIY4am//qR3F+8qYbRQF97fN0i05gHnMwSeLHOCHmADNmEPdQyjFZCl1daDxLLU6gQxrwBIr5tHL
+        1F9kqERSStjpH4qgewxJaEcgQmX6F7r9syPNmlA9PHU8WicUMHFueyBLZJqTSjyRdcIJ8YmRNHLi
+        +/oJdaxFy89zUY/anXS1TOrkq7oOHcmmjXK1B5cMP9vJ26we6RAL7/4VH/M56h9DiD3Q+mR7hhub
+        UHNcnq+okeAhQanvqVfajSHafMRXIXZrV6UcixGQgdBGW1GC+pkpF0YrJh8dpH4w0sisYJEKvLBT
+        9FqsdFFPkKy8d6SxOKDbm5rIHLW3aWpGm0HSe+4TFAuzJgCDTDrIEk/ysrVCqmlQ2TcwFHgWqjon
+        31+XtGj1C5mGt9FrkekAADkjwkvFVIVhp1kbtgdW8XYx/za60giFbazhzOOKPoq9wWq9WG9CnANT
+        3B7KKyED+oWOwWE2VsLDRIxARNSkIzPQ2lf1rAlIiM5eDYQb9QXzTvtmPkDDQlRxliIdFhRkhaKt
+        z9r6phQzUA99Q74XN25DS+7b4iu96xQNg2ysJsvgt4n2yaaSqBKTvmeA9qP6Hg4r86lw97clEfCL
+        5mWHpyrehJKy6ci/XQajNJIAfFNhLPUBRWdWiKGY2T6RGhOzKKnZngJ4bw5qLDpqn4kkO1UQVINA
+        pBGzFve2uRMk6Ih1eBhpC4V7U7B9J1gGZxO2J5pXMYoxIY7bylcqBmBnNnfqd6yeC/sRwdWxI/UJ
+        MDzZ6pYtikSPElrr1SLo9DI3xSxtxjdNLC+SDBb0VtTwnhCLagJNUh8283i9vr7Gn98Bc2zc2qQO
+        2rwIRuAQkTKJkVDhW3N946Cpg0ZklFgBtxN6lhXgdg7WLw4nVCvI7CVMgItJcjuODv6eU6Ieqqb2
+        LFQKJyAx3VqTVAmK0uoEU7dTU3HZDtoQm5Xa98nouYqixbobGJisiBMDWwue0pkd3dJfBqEVA5pk
+        NRQrqGjNcaNF3HMtBzqHPtm0ZQErB2XNIzaTCcXBJIqcSqokkyptDyU7lq3r61Ha7HOj+oBgjuXI
+        HJJm63sQdwglTEB99k6lzxZCb6dGiw6rWfh2015PRBpK0rgj8cW5ZkF71AU/jIuRb3Xlfb0KcWGc
+        Yziki0d3g/U2Hfcg2cHj2iPlMO949f1KqW985VLOblF24hnsc3ghft3t7e0n2XC33fU0yz+tyxmY
+        sa3c3d7ddx/sua+XBs3Fzc5oc6R+e3a75QEEhGbhqjn5fz/oo73l9NaP/2f7bcHAHKJ+v9ydtIfe
+        fhbpOzt8H/9sjTR/8C7BSTe0z5YistHToIur92oyYveDBX2ao5V7qmHefzJ39z/fDve/3O2u3q/+
+        BQAA//8DAPcawNa2GwAA
+    headers:
+      CF-RAY:
+      - 99c9865b6af3cf4d-SJC
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 11 Nov 2025 00:03:32 GMT
+      Server:
+      - cloudflare
+      Strict-Transport-Security:
+      - max-age=31536000; includeSubDomains; preload
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - nosniff
+      access-control-expose-headers:
+      - X-Request-ID
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - crewai-iuxna1
+      openai-processing-ms:
+      - '22788'
+      openai-project:
+      - proj_xitITlrFeen7zjNSzML82h9x
+      openai-version:
+      - '2020-10-01'
+      x-envoy-upstream-service-time:
+      - '22942'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-project-tokens:
+      - '150000000'
+      x-ratelimit-limit-requests:
+      - '30000'
+      x-ratelimit-limit-tokens:
+      - '150000000'
+      x-ratelimit-remaining-project-tokens:
+      - '149998392'
+      x-ratelimit-remaining-requests:
+      - '29999'
+      x-ratelimit-remaining-tokens:
+      - '149998392'
+      x-ratelimit-reset-project-tokens:
+      - 0s
+      x-ratelimit-reset-requests:
+      - 2ms
+      x-ratelimit-reset-tokens:
+      - 0s
+      x-request-id:
+      - req_48c359c72cdc47aeb89c6d6eeffdce7d
+    status:
+      code: 200
+      message: OK
+version: 1

lib/crewai/tests/test_agent_output_sanitization.py

@@ -1,167 +0,0 @@
-"""Tests for agent output sanitization to prevent internal fields from leaking."""
-
-import pytest
-from unittest.mock import Mock, patch
-
-from crewai import Agent, Crew, Task
-from crewai.agents.parser import AgentAction, AgentFinish
-from crewai.process import Process
-from crewai.utilities.agent_utils import (
-    format_answer,
-    handle_max_iterations_exceeded,
-)
-
-
-@pytest.fixture
-def mock_llm():
-    """Create a mock LLM that returns ReAct-style output."""
-    llm = Mock()
-    llm.call = Mock()
-    llm.supports_stop_words = Mock(return_value=True)
-    llm.get_context_window_size = Mock(return_value=4096)
-    return llm
-
-
-@pytest.fixture
-def mock_printer():
-    """Create a mock printer."""
-    printer = Mock()
-    printer.print = Mock()
-    return printer
-
-
-@pytest.fixture
-def mock_i18n():
-    """Create a mock i18n."""
-    i18n = Mock()
-    i18n.errors = Mock(return_value="Please provide a final answer.")
-    return i18n
-
-
-def test_handle_max_iterations_with_agent_action_should_not_leak_internal_fields(
-    mock_llm, mock_printer, mock_i18n
-):
-    """Test that when max iterations is exceeded and we have an AgentAction,
-    the final output doesn't contain internal ReAct fields like 'Thought:' and 'Action:'.
-    
-    This reproduces issue #3873 where hierarchical crews would return internal
-    fields in the final answer when delegated tasks failed.
-    """
-    formatted_answer = AgentAction(
-        thought="I need to fetch the database tables",
-        tool="PostgresTool",
-        tool_input="list_tables",
-        text="Thought: I need to fetch the database tables\nAction: PostgresTool\nAction Input: list_tables",
-    )
-    
-    messages = [
-        {"role": "system", "content": "You are a helpful assistant."},
-        {"role": "user", "content": "Fetch list of tables from postgres db"},
-    ]
-    
-    mock_llm.call.return_value = (
-        "Thought: I should try to connect to the database\n"
-        "Action: PostgresTool\n"
-        "Action Input: connect"
-    )
-    
-    callbacks = []
-    
-    result = handle_max_iterations_exceeded(
-        formatted_answer=formatted_answer,
-        printer=mock_printer,
-        i18n=mock_i18n,
-        messages=messages,
-        llm=mock_llm,
-        callbacks=callbacks,
-    )
-    
-    assert isinstance(result, AgentFinish)
-    
-    assert "Thought:" not in result.output, (
-        f"Output should not contain 'Thought:' but got: {result.output}"
-    )
-    assert "Action:" not in result.output, (
-        f"Output should not contain 'Action:' but got: {result.output}"
-    )
-    assert "Action Input:" not in result.output, (
-        f"Output should not contain 'Action Input:' but got: {result.output}"
-    )
-
-
-def test_format_answer_with_unparseable_output_should_not_leak_internal_fields():
-    """Test that when format_answer receives unparseable output with ReAct fields,
-    it sanitizes them from the final output.
-    """
-    raw_answer = (
-        "Thought: I tried to connect to the database but failed\n"
-        "Action: PostgresTool\n"
-        "Action Input: connect\n"
-        "Observation: Error: Database configuration not found"
-    )
-    
-    with patch("crewai.utilities.agent_utils.parse") as mock_parse:
-        mock_parse.side_effect = Exception("Failed to parse")
-        
-        result = format_answer(raw_answer)
-    
-    assert isinstance(result, AgentFinish)
-    
-    assert "Thought:" not in result.output, (
-        f"Output should not contain 'Thought:' but got: {result.output}"
-    )
-    assert "Action:" not in result.output, (
-        f"Output should not contain 'Action:' but got: {result.output}"
-    )
-    assert "Action Input:" not in result.output, (
-        f"Output should not contain 'Action Input:' but got: {result.output}"
-    )
-    assert "Observation:" not in result.output, (
-        f"Output should not contain 'Observation:' but got: {result.output}"
-    )
-
-
-def test_hierarchical_crew_with_failing_task_should_not_leak_internal_fields():
-    """Integration test: hierarchical crew with a failing delegated task
-    should not leak internal ReAct fields in the final output.
-    
-    This is a full integration test that reproduces issue #3873.
-    
-    Note: This test is skipped for now as it requires VCR cassettes.
-    The unit tests above cover the core functionality.
-    """
-    pytest.skip("Integration test requires VCR cassettes - covered by unit tests")
-    expert = Agent(
-        role="Database Expert",
-        goal="Fetch database information",
-        backstory="You are an expert in database operations.",
-        max_iter=2,  # Set low max_iter to trigger the bug
-        verbose=True,
-    )
-    
-    task = Task(
-        description="Fetch list of tables from postgres database",
-        expected_output="A list of database tables",
-        agent=expert,
-    )
-    
-    crew = Crew(
-        agents=[expert],
-        tasks=[task],
-        process=Process.hierarchical,
-        manager_llm="gpt-4o",
-        verbose=True,
-    )
-    
-    # Execute the crew
-    result = crew.kickoff()
-    
-    assert "Thought:" not in result.raw, (
-        f"Final output should not contain 'Thought:' but got: {result.raw}"
-    )
-    assert "Action:" not in result.raw, (
-        f"Final output should not contain 'Action:' but got: {result.raw}"
-    )
-    assert "Action Input:" not in result.raw, (
-        f"Final output should not contain 'Action Input:' but got: {result.raw}"
-    )

lib/crewai/tests/test_crew.py

@@ -340,7 +340,7 @@ def test_sync_task_execution(researcher, writer):
     )
 
     mock_task_output = TaskOutput(
-        description="Mock description", raw="mocked output", agent="mocked agent"
+        description="Mock description", raw="mocked output", agent="mocked agent", messages=[]
     )
 
     # Because we are mocking execute_sync, we never hit the underlying _execute_core
@@ -412,7 +412,7 @@ def test_manager_agent_delegating_to_assigned_task_agent(researcher, writer):
     )
 
     mock_task_output = TaskOutput(
-        description="Mock description", raw="mocked output", agent="mocked agent"
+        description="Mock description", raw="mocked output", agent="mocked agent", messages=[]
     )
 
     # Because we are mocking execute_sync, we never hit the underlying _execute_core
@@ -513,7 +513,7 @@ def test_manager_agent_delegates_with_varied_role_cases():
     )
 
     mock_task_output = TaskOutput(
-        description="Mock description", raw="mocked output", agent="mocked agent"
+        description="Mock description", raw="mocked output", agent="mocked agent", messages=[]
     )
     task.output = mock_task_output
 
@@ -611,7 +611,7 @@ def test_crew_with_delegating_agents_should_not_override_task_tools(ceo, writer)
     )
 
     mock_task_output = TaskOutput(
-        description="Mock description", raw="mocked output", agent="mocked agent"
+        description="Mock description", raw="mocked output", agent="mocked agent", messages=[]
     )
 
     # Because we are mocking execute_sync, we never hit the underlying _execute_core
@@ -669,7 +669,7 @@ def test_crew_with_delegating_agents_should_not_override_agent_tools(ceo, writer
     )
 
     mock_task_output = TaskOutput(
-        description="Mock description", raw="mocked output", agent="mocked agent"
+        description="Mock description", raw="mocked output", agent="mocked agent", messages=[]
     )
 
     # Because we are mocking execute_sync, we never hit the underlying _execute_core
@@ -788,7 +788,7 @@ def test_task_tools_override_agent_tools_with_allow_delegation(researcher, write
     )
 
     mock_task_output = TaskOutput(
-        description="Mock description", raw="mocked output", agent="mocked agent"
+        description="Mock description", raw="mocked output", agent="mocked agent", messages=[]
     )
 
     # We mock execute_sync to verify which tools get used at runtime
@@ -1225,7 +1225,7 @@ async def test_async_task_execution_call_count(researcher, writer):
 
     # Create a valid TaskOutput instance to mock the return value
     mock_task_output = TaskOutput(
-        description="Mock description", raw="mocked output", agent="mocked agent"
+        description="Mock description", raw="mocked output", agent="mocked agent", messages=[]
     )
 
     # Create a MagicMock Future instance
@@ -1784,7 +1784,7 @@ def test_hierarchical_kickoff_usage_metrics_include_manager(researcher):
         Task,
         "execute_sync",
         return_value=TaskOutput(
-            description="dummy", raw="Hello", agent=researcher.role
+            description="dummy", raw="Hello", agent=researcher.role, messages=[]
         ),
     ):
         crew.kickoff()
@@ -1828,7 +1828,7 @@ def test_hierarchical_crew_creation_tasks_with_agents(researcher, writer):
     )
 
     mock_task_output = TaskOutput(
-        description="Mock description", raw="mocked output", agent="mocked agent"
+        description="Mock description", raw="mocked output", agent="mocked agent", messages=[]
     )
 
     # Because we are mocking execute_sync, we never hit the underlying _execute_core
@@ -1881,7 +1881,7 @@ def test_hierarchical_crew_creation_tasks_with_async_execution(researcher, write
     )
 
     mock_task_output = TaskOutput(
-        description="Mock description", raw="mocked output", agent="mocked agent"
+        description="Mock description", raw="mocked output", agent="mocked agent", messages=[]
     )
 
     # Create a mock Future that returns our TaskOutput
@@ -2246,11 +2246,13 @@ def test_conditional_task_uses_last_output(researcher, writer):
         description="First task output",
         raw="First success output",  # Will be used by third task's condition
         agent=researcher.role,
+        messages=[],
     )
     mock_third = TaskOutput(
         description="Third task output",
         raw="Third task executed",  # Output when condition succeeds using first task output
         agent=writer.role,
+        messages=[],
     )
 
     # Set up mocks for task execution and conditional logic
@@ -2318,11 +2320,13 @@ def test_conditional_tasks_result_collection(researcher, writer):
         description="Success output",
         raw="Success output",  # Triggers third task's condition
         agent=researcher.role,
+        messages=[],
     )
     mock_conditional = TaskOutput(
         description="Conditional output",
         raw="Conditional task executed",
         agent=writer.role,
+        messages=[],
     )
 
     # Set up mocks for task execution and conditional logic
@@ -2399,6 +2403,7 @@ def test_multiple_conditional_tasks(researcher, writer):
         description="Mock success",
         raw="Success and proceed output",
         agent=researcher.role,
+        messages=[],
     )
 
     # Set up mocks for task execution
@@ -2806,7 +2811,7 @@ def test_manager_agent(researcher, writer):
     )
 
     mock_task_output = TaskOutput(
-        description="Mock description", raw="mocked output", agent="mocked agent"
+        description="Mock description", raw="mocked output", agent="mocked agent", messages=[]
     )
 
     # Because we are mocking execute_sync, we never hit the underlying _execute_core
@@ -3001,6 +3006,7 @@ def test_replay_feature(researcher, writer):
             output_format=OutputFormat.RAW,
             pydantic=None,
             summary="Mocked output for list of ideas",
+            messages=[],
         )
 
         crew.kickoff()
@@ -3052,6 +3058,7 @@ def test_crew_task_db_init():
             output_format=OutputFormat.RAW,
             pydantic=None,
             summary="Write about AI in healthcare...",
+            messages=[],
         )
 
         crew.kickoff()
@@ -3114,6 +3121,7 @@ def test_replay_task_with_context():
         output_format=OutputFormat.RAW,
         pydantic=None,
         summary="Detailed report on AI advancements...",
+        messages=[],
     )
     mock_task_output2 = TaskOutput(
         description="Summarize the AI advancements report.",
@@ -3123,6 +3131,7 @@ def test_replay_task_with_context():
         output_format=OutputFormat.RAW,
         pydantic=None,
         summary="Summary of the AI advancements report...",
+        messages=[],
     )
     mock_task_output3 = TaskOutput(
         description="Write an article based on the AI advancements summary.",
@@ -3132,6 +3141,7 @@ def test_replay_task_with_context():
         output_format=OutputFormat.RAW,
         pydantic=None,
         summary="Article on AI advancements...",
+        messages=[],
     )
     mock_task_output4 = TaskOutput(
         description="Create a presentation based on the AI advancements article.",
@@ -3141,6 +3151,7 @@ def test_replay_task_with_context():
         output_format=OutputFormat.RAW,
         pydantic=None,
         summary="Presentation on AI advancements...",
+        messages=[],
     )
 
     with patch.object(Task, "execute_sync") as mock_execute_task:
@@ -3164,6 +3175,70 @@ def test_replay_task_with_context():
         db_handler.reset()
 
 
+@pytest.mark.vcr(filter_headers=["authorization"])
+def test_replay_preserves_messages():
+    """Test that replay preserves messages from stored task outputs."""
+    from crewai.utilities.types import LLMMessage
+
+    agent = Agent(
+        role="Test Agent",
+        goal="Test goal",
+        backstory="Test backstory",
+        allow_delegation=False,
+    )
+
+    task = Task(
+        description="Say hello",
+        expected_output="A greeting",
+        agent=agent,
+    )
+
+    crew = Crew(agents=[agent], tasks=[task], process=Process.sequential)
+
+    mock_messages: list[LLMMessage] = [
+        {"role": "system", "content": "You are a helpful assistant."},
+        {"role": "user", "content": "Say hello"},
+        {"role": "assistant", "content": "Hello!"},
+    ]
+
+    mock_task_output = TaskOutput(
+        description="Say hello",
+        raw="Hello!",
+        agent="Test Agent",
+        messages=mock_messages,
+    )
+
+    with patch.object(Task, "execute_sync", return_value=mock_task_output):
+        crew.kickoff()
+
+    # Verify the task output was stored with messages
+    db_handler = TaskOutputStorageHandler()
+    stored_outputs = db_handler.load()
+    assert stored_outputs is not None
+    assert len(stored_outputs) > 0
+
+    # Verify messages are in the stored output
+    stored_output = stored_outputs[0]["output"]
+    assert "messages" in stored_output
+    assert len(stored_output["messages"]) == 3
+    assert stored_output["messages"][0]["role"] == "system"
+    assert stored_output["messages"][1]["role"] == "user"
+    assert stored_output["messages"][2]["role"] == "assistant"
+
+    # Replay the task and verify messages are preserved
+    with patch.object(Task, "execute_sync", return_value=mock_task_output):
+        replayed_output = crew.replay(str(task.id))
+
+    # Verify the replayed task output has messages
+    assert len(replayed_output.tasks_output) > 0
+    replayed_task_output = replayed_output.tasks_output[0]
+    assert hasattr(replayed_task_output, "messages")
+    assert isinstance(replayed_task_output.messages, list)
+    assert len(replayed_task_output.messages) == 3
+
+    db_handler.reset()
+
+
 @pytest.mark.vcr(filter_headers=["authorization"])
 def test_replay_with_context():
     agent = Agent(role="test_agent", backstory="Test Description", goal="Test Goal")
@@ -3181,6 +3256,7 @@ def test_replay_with_context():
         pydantic=None,
         json_dict={},
         output_format=OutputFormat.RAW,
+        messages=[],
     )
     task1.output = context_output
 
@@ -3241,6 +3317,7 @@ def test_replay_with_context_set_to_nullable():
             description="Test Task Output",
             raw="test raw output",
             agent="test_agent",
+            messages=[],
         )
         crew.kickoff()
 
@@ -3264,6 +3341,7 @@ def test_replay_with_invalid_task_id():
         pydantic=None,
         json_dict={},
         output_format=OutputFormat.RAW,
+        messages=[],
     )
     task1.output = context_output
 
@@ -3328,6 +3406,7 @@ def test_replay_interpolates_inputs_properly(mock_interpolate_inputs):
         pydantic=None,
         json_dict={},
         output_format=OutputFormat.RAW,
+        messages=[],
     )
     task1.output = context_output
 
@@ -3386,6 +3465,7 @@ def test_replay_setup_context():
         pydantic=None,
         json_dict={},
         output_format=OutputFormat.RAW,
+        messages=[],
     )
     task1.output = context_output
     crew = Crew(agents=[agent], tasks=[task1, task2], process=Process.sequential)
@@ -3619,6 +3699,7 @@ def test_conditional_should_skip(researcher, writer):
             description="Task 1 description",
             raw="Task 1 output",
             agent="Researcher",
+            messages=[],
         )
 
         result = crew_met.kickoff()
@@ -3653,6 +3734,7 @@ def test_conditional_should_execute(researcher, writer):
             description="Task 1 description",
             raw="Task 1 output",
             agent="Researcher",
+            messages=[],
         )
 
         crew_met.kickoff()
@@ -3824,7 +3906,7 @@ def test_task_tools_preserve_code_execution_tools():
     )
 
     mock_task_output = TaskOutput(
-        description="Mock description", raw="mocked output", agent="mocked agent"
+        description="Mock description", raw="mocked output", agent="mocked agent", messages=[]
     )
 
     with patch.object(
@@ -3878,7 +3960,7 @@ def test_multimodal_flag_adds_multimodal_tools():
     crew = Crew(agents=[multimodal_agent], tasks=[task], process=Process.sequential)
 
     mock_task_output = TaskOutput(
-        description="Mock description", raw="mocked output", agent="mocked agent"
+        description="Mock description", raw="mocked output", agent="mocked agent", messages=[]
     )
 
     # Mock execute_sync to verify the tools passed at runtime
@@ -3942,6 +4024,7 @@ def test_multimodal_agent_image_tool_handling():
         description="Mock description",
         raw="A detailed analysis of the image",
         agent="Image Analyst",
+        messages=[],
     )
 
     with patch.object(Task, "execute_sync") as mock_execute_sync:

lib/crewai/tests/test_task.py

@@ -162,6 +162,7 @@ def test_task_callback_returns_task_output():
             "name": task.name or task.description,
             "expected_output": "Bullet point list of 5 interesting ideas.",
             "output_format": OutputFormat.RAW,
+            "messages": [],
         }
         assert output_dict == expected_output
 
@@ -1680,3 +1681,44 @@ def test_task_copy_with_list_context():
     assert isinstance(copied_task2.context, list)
     assert len(copied_task2.context) == 1
     assert copied_task2.context[0] is task1
+
+
+@pytest.mark.vcr(filter_headers=["authorization"])
+def test_task_output_includes_messages():
+    """Test that TaskOutput includes messages from agent execution."""
+    researcher = Agent(
+        role="Researcher",
+        goal="Make the best research and analysis on content about AI and AI agents",
+        backstory="You're an expert researcher, specialized in technology, software engineering, AI and startups. You work as a freelancer and is now working on doing research and analysis for a new customer.",
+        allow_delegation=False,
+    )
+
+    task1 = Task(
+        description="Give me a list of 3 interesting ideas about AI.",
+        expected_output="Bullet point list of 3 ideas.",
+        agent=researcher,
+    )
+
+    task2 = Task(
+        description="Summarize the ideas from the previous task.",
+        expected_output="A summary of the ideas.",
+        agent=researcher,
+    )
+
+    crew = Crew(agents=[researcher], tasks=[task1, task2], process=Process.sequential)
+    result = crew.kickoff()
+
+    # Verify both tasks have messages
+    assert len(result.tasks_output) == 2
+
+    # Check first task output has messages
+    task1_output = result.tasks_output[0]
+    assert hasattr(task1_output, "messages")
+    assert isinstance(task1_output.messages, list)
+    assert len(task1_output.messages) > 0
+
+    # Check second task output has messages
+    task2_output = result.tasks_output[1]
+    assert hasattr(task2_output, "messages")
+    assert isinstance(task2_output.messages, list)
+    assert len(task2_output.messages) > 0

lib/crewai/tests/test_task_guardrails.py

@@ -38,6 +38,7 @@ def test_task_without_guardrail():
     agent.role = "test_agent"
     agent.execute_task.return_value = "test result"
     agent.crew = None
+    agent.last_messages = []
 
     task = create_smart_task(description="Test task", expected_output="Output")
 
@@ -56,6 +57,7 @@ def test_task_with_successful_guardrail_func():
     agent.role = "test_agent"
     agent.execute_task.return_value = "test result"
     agent.crew = None
+    agent.last_messages = []
 
     task = create_smart_task(
         description="Test task", expected_output="Output", guardrail=guardrail
@@ -76,6 +78,7 @@ def test_task_with_failing_guardrail():
     agent.role = "test_agent"
     agent.execute_task.side_effect = ["bad result", "good result"]
     agent.crew = None
+    agent.last_messages = []
 
     task = create_smart_task(
         description="Test task",
@@ -103,6 +106,7 @@ def test_task_with_guardrail_retries():
     agent.role = "test_agent"
     agent.execute_task.return_value = "bad result"
     agent.crew = None
+    agent.last_messages = []
 
     task = create_smart_task(
         description="Test task",
@@ -128,6 +132,7 @@ def test_guardrail_error_in_context():
     agent = Mock()
     agent.role = "test_agent"
     agent.crew = None
+    agent.last_messages = []
 
     task = create_smart_task(
         description="Test task",
@@ -295,6 +300,7 @@ def test_hallucination_guardrail_integration():
     agent.role = "test_agent"
     agent.execute_task.return_value = "test result"
     agent.crew = None
+    agent.last_messages = []
 
     mock_llm = Mock(spec=LLM)
     guardrail = HallucinationGuardrail(
@@ -342,6 +348,7 @@ def test_multiple_guardrails_sequential_processing():
     agent.role = "sequential_agent"
     agent.execute_task.return_value = "original text"
     agent.crew = None
+    agent.last_messages = []
 
     task = create_smart_task(
         description="Test sequential guardrails",
@@ -391,6 +398,7 @@ def test_multiple_guardrails_with_validation_failure():
     agent.role = "validation_agent"
     agent.execute_task = mock_execute_task
     agent.crew = None
+    agent.last_messages = []
 
     task = create_smart_task(
         description="Test guardrails with validation",
@@ -432,6 +440,7 @@ def test_multiple_guardrails_with_mixed_string_and_taskoutput():
     agent.role = "mixed_agent"
     agent.execute_task.return_value = "original"
     agent.crew = None
+    agent.last_messages = []
 
     task = create_smart_task(
         description="Test mixed return types",
@@ -469,6 +478,7 @@ def test_multiple_guardrails_with_retry_on_middle_guardrail():
     agent.role = "retry_agent"
     agent.execute_task.return_value = "base"
     agent.crew = None
+    agent.last_messages = []
 
     task = create_smart_task(
         description="Test retry in middle guardrail",
@@ -500,6 +510,7 @@ def test_multiple_guardrails_with_max_retries_exceeded():
     agent.role = "failing_agent"
     agent.execute_task.return_value = "test"
     agent.crew = None
+    agent.last_messages = []
 
     task = create_smart_task(
         description="Test max retries with multiple guardrails",
@@ -523,6 +534,7 @@ def test_multiple_guardrails_empty_list():
     agent.role = "empty_agent"
     agent.execute_task.return_value = "no guardrails"
     agent.crew = None
+    agent.last_messages = []
 
     task = create_smart_task(
         description="Test empty guardrails list",
@@ -582,6 +594,7 @@ def test_multiple_guardrails_processing_order():
     agent.role = "order_agent"
     agent.execute_task.return_value = "base"
     agent.crew = None
+    agent.last_messages = []
 
     task = create_smart_task(
         description="Test processing order",
@@ -625,6 +638,7 @@ def test_multiple_guardrails_with_pydantic_output():
     agent.role = "pydantic_agent"
     agent.execute_task.return_value = "test content"
     agent.crew = None
+    agent.last_messages = []
 
     task = create_smart_task(
         description="Test guardrails with Pydantic",
@@ -658,6 +672,7 @@ def test_guardrails_vs_single_guardrail_mutual_exclusion():
     agent.role = "exclusion_agent"
     agent.execute_task.return_value = "test"
     agent.crew = None
+    agent.last_messages = []
 
     task = create_smart_task(
         description="Test mutual exclusion",
@@ -700,6 +715,7 @@ def test_per_guardrail_independent_retry_tracking():
     agent.role = "independent_retry_agent"
     agent.execute_task.return_value = "base"
     agent.crew = None
+    agent.last_messages = []
 
     task = create_smart_task(
         description="Test independent retry tracking",

pyproject.toml

@@ -15,7 +15,7 @@ dev = [
     "pytest>=8.4.2",
     "pytest-asyncio>=1.2.0",
     "pytest-subprocess>=1.5.3",
-    "vcrpy==7.0.0",
+    "vcrpy==7.0.0", # pinned, less versions break pytest-recording
     "pytest-recording>=0.13.4",
     "pytest-randomly>=4.0.1",
     "pytest-timeout>=2.4.0",