chore: refactor crew to provider

Enable dynamic extension exports and small behavior fixes across events and flow modules: - events/__init__.py: Added _extension_exports and extended __getattr__ to lazily resolve registered extension values or import paths. - events/event_bus.py: Implemented off() to unregister sync/async handlers, clean handler dependencies, and invalidate execution plan cache. - events/listeners/tracing/utils.py: Added Callable import and _first_time_trace_hook to allow overriding first-time trace auto-collection behavior. - events/types/tool_usage_events.py: Changed ToolUsageEvent.run_attempts default from None to 0 to avoid nullable handling. - events/utils/console_formatter.py: Respect CREWAI_DISABLE_VERSION_CHECK env var to skip version checks in CI-like flows. - flow/async_feedback/__init__.py: Added typing.Any import, _extension_exports and __getattr__ to support extensions via attribute lookup. These changes add extension points and safer defaults, and provide a way to unregister event handlers.
refactor: extract hitl to provider pattern
2026-02-04 21:18:13 +00:00 · 2026-02-04 16:05:21 -05:00 · 2026-02-04 15:40:22 -05:00 · 2026-02-03 20:47:58 -05:00 · 2026-02-03 16:30:43 -08:00
27 changed files with 1445 additions and 425 deletions
--- a/lib/crewai-tools/src/crewai_tools/adapters/mcp_adapter.py
+++ b/lib/crewai-tools/src/crewai_tools/adapters/mcp_adapter.py
@@ -2,29 +2,95 @@

 from __future__ import annotations

+from collections.abc import Callable
 import logging
 from typing import TYPE_CHECKING, Any

 from crewai.tools import BaseTool
+from crewai.utilities.pydantic_schema_utils import create_model_from_schema
+from crewai.utilities.string_utils import sanitize_tool_name
+from pydantic import BaseModel

 from crewai_tools.adapters.tool_collection import ToolCollection


-logger = logging.getLogger(__name__)
-
 if TYPE_CHECKING:
    from mcp import StdioServerParameters
-    from mcpadapt.core import MCPAdapt
-    from mcpadapt.crewai_adapter import CrewAIAdapter
+    from mcp.types import CallToolResult, TextContent, Tool
+    from mcpadapt.core import MCPAdapt, ToolAdapter
+
+
+logger = logging.getLogger(__name__)


 try:
    from mcp import StdioServerParameters
-    from mcpadapt.core import MCPAdapt
-    from mcpadapt.crewai_adapter import CrewAIAdapter
+    from mcp.types import CallToolResult, TextContent, Tool
+    from mcpadapt.core import MCPAdapt, ToolAdapter
+
+    class CrewAIToolAdapter(ToolAdapter):
+        """Adapter that creates CrewAI tools with properly normalized JSON schemas.
+
+        This adapter bypasses mcpadapt's model creation which adds invalid null values
+        to field schemas, instead using CrewAI's own schema utilities.
+        """
+
+        def adapt(
+            self,
+            func: Callable[[dict[str, Any] | None], CallToolResult],
+            mcp_tool: Tool,
+        ) -> BaseTool:
+            """Adapt a MCP tool to a CrewAI tool.
+
+            Args:
+                func: The function to call when the tool is invoked.
+                mcp_tool: The MCP tool definition to adapt.
+
+            Returns:
+                A CrewAI BaseTool instance.
+            """
+            tool_name = sanitize_tool_name(mcp_tool.name)
+            tool_description = mcp_tool.description or ""
+            args_model = create_model_from_schema(mcp_tool.inputSchema)
+
+            class CrewAIMCPTool(BaseTool):
+                name: str = tool_name
+                description: str = tool_description
+                args_schema: type[BaseModel] = args_model
+
+                def _run(self, **kwargs: Any) -> Any:
+                    result = func(kwargs)
+                    if len(result.content) == 1:
+                        first_content = result.content[0]
+                        if isinstance(first_content, TextContent):
+                            return first_content.text
+                        return str(first_content)
+                    return str(
+                        [
+                            content.text
+                            for content in result.content
+                            if isinstance(content, TextContent)
+                        ]
+                    )
+
+                def _generate_description(self) -> None:
+                    schema = self.args_schema.model_json_schema()
+                    schema.pop("$defs", None)
+                    self.description = (
+                        f"Tool Name: {self.name}\n"
+                        f"Tool Arguments: {schema}\n"
+                        f"Tool Description: {self.description}"
+                    )
+
+            return CrewAIMCPTool()
+
+        async def async_adapt(self, afunc: Any, mcp_tool: Tool) -> Any:
+            """Async adaptation is not supported by CrewAI."""
+            raise NotImplementedError("async is not supported by the CrewAI framework.")

    MCP_AVAILABLE = True
-except ImportError:
+except ImportError as e:
+    logger.debug(f"MCP packages not available: {e}")
    MCP_AVAILABLE = False


@@ -34,9 +100,6 @@ class MCPServerAdapter:
    Note: tools can only be accessed after the server has been started with the
        `start()` method.

-    Attributes:
-        tools: The CrewAI tools available from the MCP server.
-
    Usage:
        # context manager + stdio
        with MCPServerAdapter(...) as tools:
@@ -89,7 +152,9 @@ class MCPServerAdapter:
        super().__init__()
        self._adapter = None
        self._tools = None
-        self._tool_names = list(tool_names) if tool_names else None
+        self._tool_names = (
+            [sanitize_tool_name(name) for name in tool_names] if tool_names else None
+        )

        if not MCP_AVAILABLE:
            import click
@@ -100,7 +165,7 @@ class MCPServerAdapter:
                import subprocess

                try:
-                    subprocess.run(["uv", "add", "mcp crewai-tools[mcp]"], check=True)  # noqa: S607
+                    subprocess.run(["uv", "add", "mcp crewai-tools'[mcp]'"], check=True)  # noqa: S607

                except subprocess.CalledProcessError as e:
                    raise ImportError("Failed to install mcp package") from e
@@ -112,7 +177,7 @@ class MCPServerAdapter:
        try:
            self._serverparams = serverparams
            self._adapter = MCPAdapt(
-                self._serverparams, CrewAIAdapter(), connect_timeout
+                self._serverparams, CrewAIToolAdapter(), connect_timeout
            )
            self.start()

@@ -124,13 +189,13 @@ class MCPServerAdapter:
                    logger.error(f"Error during stop cleanup: {stop_e}")
            raise RuntimeError(f"Failed to initialize MCP Adapter: {e}") from e

-    def start(self):
+    def start(self) -> None:
        """Start the MCP server and initialize the tools."""
-        self._tools = self._adapter.__enter__()
+        self._tools = self._adapter.__enter__()  # type: ignore[union-attr]

-    def stop(self):
+    def stop(self) -> None:
        """Stop the MCP server."""
-        self._adapter.__exit__(None, None, None)
+        self._adapter.__exit__(None, None, None)  # type: ignore[union-attr]

    @property
    def tools(self) -> ToolCollection[BaseTool]:
@@ -152,12 +217,19 @@ class MCPServerAdapter:
            return tools_collection.filter_by_names(self._tool_names)
        return tools_collection

-    def __enter__(self):
-        """Enter the context manager. Note that `__init__()` already starts the MCP server.
-        So tools should already be available.
+    def __enter__(self) -> ToolCollection[BaseTool]:
+        """Enter the context manager.
+
+        Note that `__init__()` already starts the MCP server,
+        so tools should already be available.
        """
        return self.tools

-    def __exit__(self, exc_type, exc_value, traceback):
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: Any,
+    ) -> None:
        """Exit the context manager."""
-        return self._adapter.__exit__(exc_type, exc_value, traceback)
+        self._adapter.__exit__(exc_type, exc_value, traceback)  # type: ignore[union-attr]
--- a/lib/crewai-tools/tool.specs.json
+++ b/lib/crewai-tools/tool.specs.json
@@ -197,7 +197,7 @@
      }
    },
    {
-      "description": "A tool that can be used to search the internet with a search_query.",
+      "description": "A tool that performs web searches using the Brave Search API. Results are returned as structured JSON data.",
      "env_vars": [
        {
          "default": null,
@@ -206,7 +206,7 @@
          "required": true
        }
      ],
-      "humanized_name": "Brave Web Search the internet",
+      "humanized_name": "Brave Search",
      "init_params_schema": {
        "$defs": {
          "EnvVar": {
@@ -245,20 +245,8 @@
            "type": "object"
          }
        },
-        "description": "BraveSearchTool - A tool for performing web searches using the Brave Search API.\n\nThis module provides functionality to search the internet using Brave's Search API,\nsupporting customizable result counts and country-specific searches.\n\nDependencies:\n    - requests\n    - pydantic\n    - python-dotenv (for API key management)",
+        "description": "A tool that performs web searches using the Brave Search API.",
        "properties": {
-          "country": {
-            "anyOf": [
-              {
-                "type": "string"
-              },
-              {
-                "type": "null"
-              }
-            ],
-            "default": "",
-            "title": "Country"
-          },
          "n_results": {
            "default": 10,
            "title": "N Results",
@@ -281,16 +269,161 @@
      "name": "BraveSearchTool",
      "package_dependencies": [],
      "run_params_schema": {
-        "description": "Input for BraveSearchTool.",
+        "description": "Input for BraveSearchTool",
        "properties": {
-          "search_query": {
-            "description": "Mandatory search query you want to use to search the internet",
-            "title": "Search Query",
+          "count": {
+            "anyOf": [
+              {
+                "type": "integer"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "default": null,
+            "description": "The maximum number of results to return. Actual number may be less.",
+            "title": "Count"
+          },
+          "country": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "default": null,
+            "description": "Country code for geo-targeting (e.g., 'US', 'BR').",
+            "title": "Country"
+          },
+          "extra_snippets": {
+            "anyOf": [
+              {
+                "type": "boolean"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "default": null,
+            "description": "Include up to 5 text snippets for each page if possible.",
+            "title": "Extra Snippets"
+          },
+          "freshness": {
+            "anyOf": [
+              {
+                "enum": [
+                  "pd",
+                  "pw",
+                  "pm",
+                  "py"
+                ],
+                "type": "string"
+              },
+              {
+                "pattern": "^\\d{4}-\\d{2}-\\d{2}to\\d{4}-\\d{2}-\\d{2}$",
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "default": null,
+            "description": "Enforce freshness of results. Options: pd/pw/pm/py, or YYYY-MM-DDtoYYYY-MM-DD",
+            "title": "Freshness"
+          },
+          "offset": {
+            "anyOf": [
+              {
+                "type": "integer"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "default": null,
+            "description": "Skip the first N result sets/pages. Max is 9.",
+            "title": "Offset"
+          },
+          "operators": {
+            "anyOf": [
+              {
+                "type": "boolean"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "default": null,
+            "description": "Whether to apply search operators (e.g., site:example.com).",
+            "title": "Operators"
+          },
+          "query": {
+            "description": "Search query to perform",
+            "title": "Query",
            "type": "string"
+          },
+          "safesearch": {
+            "anyOf": [
+              {
+                "enum": [
+                  "off",
+                  "moderate",
+                  "strict"
+                ],
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "default": null,
+            "description": "Filter out explicit content. Options: off/moderate/strict",
+            "title": "Safesearch"
+          },
+          "search_language": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "default": null,
+            "description": "Language code for the search results (e.g., 'en', 'es').",
+            "title": "Search Language"
+          },
+          "spellcheck": {
+            "anyOf": [
+              {
+                "type": "boolean"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "default": null,
+            "description": "Attempt to correct spelling errors in the search query.",
+            "title": "Spellcheck"
+          },
+          "text_decorations": {
+            "anyOf": [
+              {
+                "type": "boolean"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "default": null,
+            "description": "Include markup to highlight search terms in the results.",
+            "title": "Text Decorations"
          }
        },
        "required": [
-          "search_query"
+          "query"
        ],
        "title": "BraveSearchToolSchema",
        "type": "object"
@@ -3741,10 +3874,6 @@
            "title": "Bucket Name",
            "type": "string"
          },
-          "cluster": {
-            "description": "An instance of the Couchbase Cluster connected to the desired Couchbase server.",
-            "title": "Cluster"
-          },
          "collection_name": {
            "description": "The name of the Couchbase collection to search",
            "title": "Collection Name",
@@ -3793,7 +3922,6 @@
          }
        },
        "required": [
-          "cluster",
          "collection_name",
          "scope_name",
          "bucket_name",
@@ -12537,13 +12665,9 @@
        "properties": {
          "config": {
            "$ref": "#/$defs/OxylabsAmazonProductScraperConfig"
-          },
-          "oxylabs_api": {
-            "title": "Oxylabs Api"
          }
        },
        "required": [
-          "oxylabs_api",
          "config"
        ],
        "title": "OxylabsAmazonProductScraperTool",
@@ -12766,13 +12890,9 @@
        "properties": {
          "config": {
            "$ref": "#/$defs/OxylabsAmazonSearchScraperConfig"
-          },
-          "oxylabs_api": {
-            "title": "Oxylabs Api"
          }
        },
        "required": [
-          "oxylabs_api",
          "config"
        ],
        "title": "OxylabsAmazonSearchScraperTool",
@@ -13008,13 +13128,9 @@
        "properties": {
          "config": {
            "$ref": "#/$defs/OxylabsGoogleSearchScraperConfig"
-          },
-          "oxylabs_api": {
-            "title": "Oxylabs Api"
          }
        },
        "required": [
-          "oxylabs_api",
          "config"
        ],
        "title": "OxylabsGoogleSearchScraperTool",
@@ -13198,13 +13314,9 @@
        "properties": {
          "config": {
            "$ref": "#/$defs/OxylabsUniversalScraperConfig"
-          },
-          "oxylabs_api": {
-            "title": "Oxylabs Api"
          }
        },
        "required": [
-          "oxylabs_api",
          "config"
        ],
        "title": "OxylabsUniversalScraperTool",
@@ -20005,6 +20117,18 @@
      "humanized_name": "Web Automation Tool",
      "init_params_schema": {
        "$defs": {
+          "AvailableModel": {
+            "enum": [
+              "gpt-4o",
+              "gpt-4o-mini",
+              "claude-3-5-sonnet-latest",
+              "claude-3-7-sonnet-latest",
+              "computer-use-preview",
+              "gemini-2.0-flash"
+            ],
+            "title": "AvailableModel",
+            "type": "string"
+          },
          "EnvVar": {
            "properties": {
              "default": {
@@ -20082,6 +20206,17 @@
            "default": null,
            "title": "Model Api Key"
          },
+          "model_name": {
+            "anyOf": [
+              {
+                "$ref": "#/$defs/AvailableModel"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "default": "claude-3-7-sonnet-latest"
+          },
          "project_id": {
            "anyOf": [
              {
@@ -21306,26 +21441,6 @@
            "description": "The Tavily API key. If not provided, it will be loaded from the environment variable TAVILY_API_KEY.",
            "title": "Api Key"
          },
-          "async_client": {
-            "anyOf": [
-              {},
-              {
-                "type": "null"
-              }
-            ],
-            "default": null,
-            "title": "Async Client"
-          },
-          "client": {
-            "anyOf": [
-              {},
-              {
-                "type": "null"
-              }
-            ],
-            "default": null,
-            "title": "Client"
-          },
          "extract_depth": {
            "default": "basic",
            "description": "The depth of extraction. 'basic' for basic extraction, 'advanced' for advanced extraction.",
@@ -21461,26 +21576,6 @@
            "description": "The Tavily API key. If not provided, it will be loaded from the environment variable TAVILY_API_KEY.",
            "title": "Api Key"
          },
-          "async_client": {
-            "anyOf": [
-              {},
-              {
-                "type": "null"
-              }
-            ],
-            "default": null,
-            "title": "Async Client"
-          },
-          "client": {
-            "anyOf": [
-              {},
-              {
-                "type": "null"
-              }
-            ],
-            "default": null,
-            "title": "Client"
-          },
          "days": {
            "default": 7,
            "description": "The number of days to search back.",
--- a/lib/crewai/src/crewai/agent/core.py
+++ b/lib/crewai/src/crewai/agent/core.py
@@ -118,6 +118,8 @@ MCP_TOOL_EXECUTION_TIMEOUT: Final[int] = 30
 MCP_DISCOVERY_TIMEOUT: Final[int] = 15
 MCP_MAX_RETRIES: Final[int] = 3

+_passthrough_exceptions: tuple[type[Exception], ...] = ()
+
 # Simple in-memory cache for MCP tool schemas (duration: 5 minutes)
 _mcp_schema_cache: dict[str, Any] = {}
 _cache_ttl: Final[int] = 300  # 5 minutes
@@ -479,6 +481,8 @@ class Agent(BaseAgent):
                    ),
                )
                raise e
+            if isinstance(e, _passthrough_exceptions):
+                raise
            self._times_executed += 1
            if self._times_executed > self.max_retry_limit:
                crewai_event_bus.emit(
@@ -711,6 +715,8 @@ class Agent(BaseAgent):
                    ),
                )
                raise e
+            if isinstance(e, _passthrough_exceptions):
+                raise
            self._times_executed += 1
            if self._times_executed > self.max_retry_limit:
                crewai_event_bus.emit(
--- a/lib/crewai/src/crewai/agents/agent_builder/base_agent_executor_mixin.py
+++ b/lib/crewai/src/crewai/agents/agent_builder/base_agent_executor_mixin.py
@@ -4,7 +4,6 @@ import time
 from typing import TYPE_CHECKING

 from crewai.agents.parser import AgentFinish
-from crewai.events.event_listener import event_listener
 from crewai.memory.entity.entity_memory_item import EntityMemoryItem
 from crewai.memory.long_term.long_term_memory_item import LongTermMemoryItem
 from crewai.utilities.converter import ConverterError
@@ -138,52 +137,3 @@ class CrewAgentExecutorMixin:
                    content="Long term memory is enabled, but entity memory is not enabled. Please configure entity memory or set memory=True to automatically enable it.",
                    color="bold_yellow",
                )
-
-    def _ask_human_input(self, final_answer: str) -> str:
-        """Prompt human input with mode-appropriate messaging.
-
-        Note: The final answer is already displayed via the AgentLogsExecutionEvent
-        panel, so we only show the feedback prompt here.
-        """
-        from rich.panel import Panel
-        from rich.text import Text
-
-        formatter = event_listener.formatter
-        formatter.pause_live_updates()
-
-        try:
-            # Training mode prompt (single iteration)
-            if self.crew and getattr(self.crew, "_train", False):
-                prompt_text = (
-                    "TRAINING MODE: Provide feedback to improve the agent's performance.\n\n"
-                    "This will be used to train better versions of the agent.\n"
-                    "Please provide detailed feedback about the result quality and reasoning process."
-                )
-                title = "🎓 Training Feedback Required"
-            # Regular human-in-the-loop prompt (multiple iterations)
-            else:
-                prompt_text = (
-                    "Provide feedback on the Final Result above.\n\n"
-                    "• If you are happy with the result, simply hit Enter without typing anything.\n"
-                    "• Otherwise, provide specific improvement requests.\n"
-                    "• You can provide multiple rounds of feedback until satisfied."
-                )
-                title = "💬 Human Feedback Required"
-
-            content = Text()
-            content.append(prompt_text, style="yellow")
-
-            prompt_panel = Panel(
-                content,
-                title=title,
-                border_style="yellow",
-                padding=(1, 2),
-            )
-            formatter.console.print(prompt_panel)
-
-            response = input()
-            if response.strip() != "":
-                formatter.console.print("\n[cyan]Processing your feedback...[/cyan]")
-            return response
-        finally:
-            formatter.resume_live_updates()
--- a/lib/crewai/src/crewai/agents/crew_agent_executor.py
+++ b/lib/crewai/src/crewai/agents/crew_agent_executor.py
@@ -19,6 +19,7 @@ from crewai.agents.parser import (
    AgentFinish,
    OutputParserError,
 )
+from crewai.core.providers.human_input import ExecutorContext, get_provider
 from crewai.events.event_bus import crewai_event_bus
 from crewai.events.types.logging_events import (
    AgentLogsExecutionEvent,
@@ -175,15 +176,16 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
        """
        return self.llm.supports_stop_words() if self.llm else False

-    def invoke(self, inputs: dict[str, Any]) -> dict[str, Any]:
-        """Execute the agent with given inputs.
+    def _setup_messages(self, inputs: dict[str, Any]) -> None:
+        """Set up messages for the agent execution.

        Args:
            inputs: Input dictionary containing prompt variables.
-
-        Returns:
-            Dictionary with agent output.
        """
+        provider = get_provider()
+        if provider.setup_messages(cast(ExecutorContext, cast(object, self))):
+            return
+
        if "system" in self.prompt:
            system_prompt = self._format_prompt(
                cast(str, self.prompt.get("system", "")), inputs
@@ -197,6 +199,19 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
            user_prompt = self._format_prompt(self.prompt.get("prompt", ""), inputs)
            self.messages.append(format_message_for_llm(user_prompt))

+        provider.post_setup_messages(cast(ExecutorContext, cast(object, self)))
+
+    def invoke(self, inputs: dict[str, Any]) -> dict[str, Any]:
+        """Execute the agent with given inputs.
+
+        Args:
+            inputs: Input dictionary containing prompt variables.
+
+        Returns:
+            Dictionary with agent output.
+        """
+        self._setup_messages(inputs)
+
        self._inject_multimodal_files(inputs)

        self._show_start_logs()
@@ -970,18 +985,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
        Returns:
            Dictionary with agent output.
        """
-        if "system" in self.prompt:
-            system_prompt = self._format_prompt(
-                cast(str, self.prompt.get("system", "")), inputs
-            )
-            user_prompt = self._format_prompt(
-                cast(str, self.prompt.get("user", "")), inputs
-            )
-            self.messages.append(format_message_for_llm(system_prompt, role="system"))
-            self.messages.append(format_message_for_llm(user_prompt))
-        else:
-            user_prompt = self._format_prompt(self.prompt.get("prompt", ""), inputs)
-            self.messages.append(format_message_for_llm(user_prompt))
+        self._setup_messages(inputs)

        await self._ainject_multimodal_files(inputs)

@@ -1491,7 +1495,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
        return prompt.replace("{tools}", inputs["tools"])

    def _handle_human_feedback(self, formatted_answer: AgentFinish) -> AgentFinish:
-        """Process human feedback.
+        """Process human feedback via the configured provider.

        Args:
            formatted_answer: Initial agent result.
@@ -1499,17 +1503,8 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
        Returns:
            Final answer after feedback.
        """
-        output_str = (
-            formatted_answer.output
-            if isinstance(formatted_answer.output, str)
-            else formatted_answer.output.model_dump_json()
-        )
-        human_feedback = self._ask_human_input(output_str)
-
-        if self._is_training_mode():
-            return self._handle_training_feedback(formatted_answer, human_feedback)
-
-        return self._handle_regular_feedback(formatted_answer, human_feedback)
+        provider = get_provider()
+        return provider.handle_feedback(formatted_answer, self)

    def _is_training_mode(self) -> bool:
        """Check if training mode is active.
@@ -1519,74 +1514,18 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
        """
        return bool(self.crew and self.crew._train)

-    def _handle_training_feedback(
-        self, initial_answer: AgentFinish, feedback: str
-    ) -> AgentFinish:
-        """Process training feedback.
+    def _format_feedback_message(self, feedback: str) -> LLMMessage:
+        """Format feedback as a message for the LLM.

        Args:
-            initial_answer: Initial agent output.
-            feedback: Training feedback.
+            feedback: User feedback string.

        Returns:
-            Improved answer.
+            Formatted message dict.
        """
-        self._handle_crew_training_output(initial_answer, feedback)
-        self.messages.append(
-            format_message_for_llm(
-                self._i18n.slice("feedback_instructions").format(feedback=feedback)
-            )
+        return format_message_for_llm(
+            self._i18n.slice("feedback_instructions").format(feedback=feedback)
        )
-        improved_answer = self._invoke_loop()
-        self._handle_crew_training_output(improved_answer)
-        self.ask_for_human_input = False
-        return improved_answer
-
-    def _handle_regular_feedback(
-        self, current_answer: AgentFinish, initial_feedback: str
-    ) -> AgentFinish:
-        """Process regular feedback iteratively.
-
-        Args:
-            current_answer: Current agent output.
-            initial_feedback: Initial user feedback.
-
-        Returns:
-            Final answer after iterations.
-        """
-        feedback = initial_feedback
-        answer = current_answer
-
-        while self.ask_for_human_input:
-            # If the user provides a blank response, assume they are happy with the result
-            if feedback.strip() == "":
-                self.ask_for_human_input = False
-            else:
-                answer = self._process_feedback_iteration(feedback)
-                output_str = (
-                    answer.output
-                    if isinstance(answer.output, str)
-                    else answer.output.model_dump_json()
-                )
-                feedback = self._ask_human_input(output_str)
-
-        return answer
-
-    def _process_feedback_iteration(self, feedback: str) -> AgentFinish:
-        """Process single feedback iteration.
-
-        Args:
-            feedback: User feedback.
-
-        Returns:
-            Updated agent response.
-        """
-        self.messages.append(
-            format_message_for_llm(
-                self._i18n.slice("feedback_instructions").format(feedback=feedback)
-            )
-        )
-        return self._invoke_loop()

    @classmethod
    def __get_pydantic_core_schema__(
--- a/lib/crewai/src/crewai/core/init.py
+++ b/lib/crewai/src/crewai/core/init.py
@@ -0,0 +1 @@
+"""Core crewAI components and interfaces."""
--- a/lib/crewai/src/crewai/core/providers/init.py
+++ b/lib/crewai/src/crewai/core/providers/init.py
@@ -0,0 +1 @@
+"""Provider interfaces for extensible crewAI components."""
--- a/lib/crewai/src/crewai/core/providers/content_processor.py
+++ b/lib/crewai/src/crewai/core/providers/content_processor.py
@@ -0,0 +1,78 @@
+"""Content processor provider for extensible content processing."""
+
+from contextvars import ContextVar
+from typing import Any, Protocol, runtime_checkable
+
+
+@runtime_checkable
+class ContentProcessorProvider(Protocol):
+    """Protocol for content processing during task execution."""
+
+    def process(self, content: str, context: dict[str, Any] | None = None) -> str:
+        """Process content before use.
+
+        Args:
+            content: The content to process.
+            context: Optional context information.
+
+        Returns:
+            The processed content.
+        """
+        ...
+
+
+class NoOpContentProcessor:
+    """Default processor that returns content unchanged."""
+
+    def process(self, content: str, context: dict[str, Any] | None = None) -> str:
+        """Return content unchanged.
+
+        Args:
+            content: The content to process.
+            context: Optional context information (unused).
+
+        Returns:
+            The original content unchanged.
+        """
+        return content
+
+
+_content_processor: ContextVar[ContentProcessorProvider | None] = ContextVar(
+    "_content_processor", default=None
+)
+
+_default_processor = NoOpContentProcessor()
+
+
+def get_processor() -> ContentProcessorProvider:
+    """Get the current content processor.
+
+    Returns:
+        The registered content processor or the default no-op processor.
+    """
+    processor = _content_processor.get()
+    if processor is not None:
+        return processor
+    return _default_processor
+
+
+def set_processor(processor: ContentProcessorProvider) -> None:
+    """Set the content processor for the current context.
+
+    Args:
+        processor: The content processor to use.
+    """
+    _content_processor.set(processor)
+
+
+def process_content(content: str, context: dict[str, Any] | None = None) -> str:
+    """Process content using the registered processor.
+
+    Args:
+        content: The content to process.
+        context: Optional context information.
+
+    Returns:
+        The processed content.
+    """
+    return get_processor().process(content, context)
--- a/lib/crewai/src/crewai/core/providers/human_input.py
+++ b/lib/crewai/src/crewai/core/providers/human_input.py
@@ -0,0 +1,304 @@
+"""Human input provider for HITL (Human-in-the-Loop) flows."""
+
+from __future__ import annotations
+
+from contextvars import ContextVar, Token
+from typing import TYPE_CHECKING, Protocol, runtime_checkable
+
+
+if TYPE_CHECKING:
+    from crewai.agent.core import Agent
+    from crewai.agents.parser import AgentFinish
+    from crewai.crew import Crew
+    from crewai.llms.base_llm import BaseLLM
+    from crewai.task import Task
+    from crewai.utilities.types import LLMMessage
+
+
+class ExecutorContext(Protocol):
+    """Context interface for human input providers to interact with executor."""
+
+    task: Task | None
+    crew: Crew | None
+    messages: list[LLMMessage]
+    ask_for_human_input: bool
+    llm: BaseLLM
+    agent: Agent
+
+    def _invoke_loop(self) -> AgentFinish:
+        """Invoke the agent loop and return the result."""
+        ...
+
+    def _is_training_mode(self) -> bool:
+        """Check if training mode is active."""
+        ...
+
+    def _handle_crew_training_output(
+        self,
+        result: AgentFinish,
+        human_feedback: str | None = None,
+    ) -> None:
+        """Handle training output."""
+        ...
+
+    def _format_feedback_message(self, feedback: str) -> LLMMessage:
+        """Format feedback as a message."""
+        ...
+
+
+@runtime_checkable
+class HumanInputProvider(Protocol):
+    """Protocol for human input handling.
+
+    Implementations handle the full feedback flow:
+    - Sync: prompt user, loop until satisfied
+    - Async: raise exception for external handling
+    """
+
+    def setup_messages(self, context: ExecutorContext) -> bool:
+        """Set up messages for execution.
+
+        Called before standard message setup. Allows providers to handle
+        conversation resumption or other custom message initialization.
+
+        Args:
+            context: Executor context with messages list to modify.
+
+        Returns:
+            True if messages were set up (skip standard setup),
+            False to use standard setup.
+        """
+        ...
+
+    def post_setup_messages(self, context: ExecutorContext) -> None:
+        """Called after standard message setup.
+
+        Allows providers to modify messages after standard setup completes.
+        Only called when setup_messages returned False.
+
+        Args:
+            context: Executor context with messages list to modify.
+        """
+        ...
+
+    def handle_feedback(
+        self,
+        formatted_answer: AgentFinish,
+        context: ExecutorContext,
+    ) -> AgentFinish:
+        """Handle the full human feedback flow.
+
+        Args:
+            formatted_answer: The agent's current answer.
+            context: Executor context for callbacks.
+
+        Returns:
+            The final answer after feedback processing.
+
+        Raises:
+            Exception: Async implementations may raise to signal external handling.
+        """
+        ...
+
+    @staticmethod
+    def _get_output_string(answer: AgentFinish) -> str:
+        """Extract output string from answer.
+
+        Args:
+            answer: The agent's finished answer.
+
+        Returns:
+            String representation of the output.
+        """
+        if isinstance(answer.output, str):
+            return answer.output
+        return answer.output.model_dump_json()
+
+
+class SyncHumanInputProvider(HumanInputProvider):
+    """Default synchronous human input via terminal."""
+
+    def setup_messages(self, context: ExecutorContext) -> bool:
+        """Use standard message setup.
+
+        Args:
+            context: Executor context (unused).
+
+        Returns:
+            False to use standard setup.
+        """
+        return False
+
+    def post_setup_messages(self, context: ExecutorContext) -> None:
+        """No-op for sync provider.
+
+        Args:
+            context: Executor context (unused).
+        """
+
+    def handle_feedback(
+        self,
+        formatted_answer: AgentFinish,
+        context: ExecutorContext,
+    ) -> AgentFinish:
+        """Handle feedback synchronously with terminal prompts.
+
+        Args:
+            formatted_answer: The agent's current answer.
+            context: Executor context for callbacks.
+
+        Returns:
+            The final answer after feedback processing.
+        """
+        feedback = self._prompt_input(context.crew)
+
+        if context._is_training_mode():
+            return self._handle_training_feedback(formatted_answer, feedback, context)
+
+        return self._handle_regular_feedback(formatted_answer, feedback, context)
+
+    @staticmethod
+    def _handle_training_feedback(
+        initial_answer: AgentFinish,
+        feedback: str,
+        context: ExecutorContext,
+    ) -> AgentFinish:
+        """Process training feedback (single iteration).
+
+        Args:
+            initial_answer: The agent's initial answer.
+            feedback: Human feedback string.
+            context: Executor context for callbacks.
+
+        Returns:
+            Improved answer after processing feedback.
+        """
+        context._handle_crew_training_output(initial_answer, feedback)
+        context.messages.append(context._format_feedback_message(feedback))
+        improved_answer = context._invoke_loop()
+        context._handle_crew_training_output(improved_answer)
+        context.ask_for_human_input = False
+        return improved_answer
+
+    def _handle_regular_feedback(
+        self,
+        current_answer: AgentFinish,
+        initial_feedback: str,
+        context: ExecutorContext,
+    ) -> AgentFinish:
+        """Process regular feedback with iteration loop.
+
+        Args:
+            current_answer: The agent's current answer.
+            initial_feedback: Initial human feedback string.
+            context: Executor context for callbacks.
+
+        Returns:
+            Final answer after all feedback iterations.
+        """
+        feedback = initial_feedback
+        answer = current_answer
+
+        while context.ask_for_human_input:
+            if feedback.strip() == "":
+                context.ask_for_human_input = False
+            else:
+                context.messages.append(context._format_feedback_message(feedback))
+                answer = context._invoke_loop()
+                feedback = self._prompt_input(context.crew)
+
+        return answer
+
+    @staticmethod
+    def _prompt_input(crew: Crew | None) -> str:
+        """Show rich panel and prompt for input.
+
+        Args:
+            crew: The crew instance for context.
+
+        Returns:
+            User input string from terminal.
+        """
+        from rich.panel import Panel
+        from rich.text import Text
+
+        from crewai.events.event_listener import event_listener
+
+        formatter = event_listener.formatter
+        formatter.pause_live_updates()
+
+        try:
+            if crew and getattr(crew, "_train", False):
+                prompt_text = (
+                    "TRAINING MODE: Provide feedback to improve the agent's performance.\n\n"
+                    "This will be used to train better versions of the agent.\n"
+                    "Please provide detailed feedback about the result quality and reasoning process."
+                )
+                title = "🎓 Training Feedback Required"
+            else:
+                prompt_text = (
+                    "Provide feedback on the Final Result above.\n\n"
+                    "• If you are happy with the result, simply hit Enter without typing anything.\n"
+                    "• Otherwise, provide specific improvement requests.\n"
+                    "• You can provide multiple rounds of feedback until satisfied."
+                )
+                title = "💬 Human Feedback Required"
+
+            content = Text()
+            content.append(prompt_text, style="yellow")
+
+            prompt_panel = Panel(
+                content,
+                title=title,
+                border_style="yellow",
+                padding=(1, 2),
+            )
+            formatter.console.print(prompt_panel)
+
+            response = input()
+            if response.strip() != "":
+                formatter.console.print("\n[cyan]Processing your feedback...[/cyan]")
+            return response
+        finally:
+            formatter.resume_live_updates()
+
+
+_provider: ContextVar[HumanInputProvider | None] = ContextVar(
+    "human_input_provider",
+    default=None,
+)
+
+
+def get_provider() -> HumanInputProvider:
+    """Get the current human input provider.
+
+    Returns:
+        The current provider, or a new SyncHumanInputProvider if none set.
+    """
+    provider = _provider.get()
+    if provider is None:
+        initialized_provider = SyncHumanInputProvider()
+        set_provider(initialized_provider)
+        return initialized_provider
+    return provider
+
+
+def set_provider(provider: HumanInputProvider) -> Token[HumanInputProvider | None]:
+    """Set the human input provider for the current context.
+
+    Args:
+        provider: The provider to use.
+
+    Returns:
+        Token that can be used to reset to previous value.
+    """
+    return _provider.set(provider)
+
+
+def reset_provider(token: Token[HumanInputProvider | None]) -> None:
+    """Reset the provider to its previous value.
+
+    Args:
+        token: Token returned from set_provider.
+    """
+    _provider.reset(token)
--- a/lib/crewai/src/crewai/crew.py
+++ b/lib/crewai/src/crewai/crew.py
@@ -751,6 +751,8 @@ class Crew(FlowTrackable, BaseModel):
            for after_callback in self.after_kickoff_callbacks:
                result = after_callback(result)

+            result = self._post_kickoff(result)
+
            self.usage_metrics = self.calculate_usage_metrics()

            return result
@@ -764,6 +766,9 @@ class Crew(FlowTrackable, BaseModel):
            clear_files(self.id)
            detach(token)

+    def _post_kickoff(self, result: CrewOutput) -> CrewOutput:
+        return result
+
    def kickoff_for_each(
        self,
        inputs: list[dict[str, Any]],
@@ -936,6 +941,8 @@ class Crew(FlowTrackable, BaseModel):
            for after_callback in self.after_kickoff_callbacks:
                result = after_callback(result)

+            result = self._post_kickoff(result)
+
            self.usage_metrics = self.calculate_usage_metrics()

            return result
@@ -1181,6 +1188,9 @@ class Crew(FlowTrackable, BaseModel):
            self.manager_agent = manager
        manager.crew = self

+    def _get_execution_start_index(self, tasks: list[Task]) -> int | None:
+        return None
+
    def _execute_tasks(
        self,
        tasks: list[Task],
@@ -1197,6 +1207,9 @@ class Crew(FlowTrackable, BaseModel):
        Returns:
            CrewOutput: Final output of the crew
        """
+        custom_start = self._get_execution_start_index(tasks)
+        if custom_start is not None:
+            start_index = custom_start

        task_outputs: list[TaskOutput] = []
        futures: list[tuple[Task, Future[TaskOutput], int]] = []
@@ -1305,8 +1318,10 @@ class Crew(FlowTrackable, BaseModel):
        if files:
            supported_types: list[str] = []
            if agent and agent.llm and agent.llm.supports_multimodal():
-                provider = getattr(agent.llm, "provider", None) or getattr(
-                    agent.llm, "model", "openai"
+                provider = (
+                    getattr(agent.llm, "provider", None)
+                    or getattr(agent.llm, "model", None)
+                    or "openai"
                )
                api = getattr(agent.llm, "api", None)
                supported_types = get_supported_content_types(provider, api)
--- a/lib/crewai/src/crewai/events/init.py
+++ b/lib/crewai/src/crewai/events/init.py
@@ -195,6 +195,7 @@ __all__ = [
    "ToolUsageFinishedEvent",
    "ToolUsageStartedEvent",
    "ToolValidateInputErrorEvent",
+    "_extension_exports",
    "crewai_event_bus",
 ]

@@ -210,14 +211,29 @@ _AGENT_EVENT_MAPPING = {
    "LiteAgentExecutionStartedEvent": "crewai.events.types.agent_events",
 }

+_extension_exports: dict[str, Any] = {}
+

 def __getattr__(name: str) -> Any:
-    """Lazy import for agent events to avoid circular imports."""
+    """Lazy import for agent events and registered extensions."""
    if name in _AGENT_EVENT_MAPPING:
        import importlib

        module_path = _AGENT_EVENT_MAPPING[name]
        module = importlib.import_module(module_path)
        return getattr(module, name)
+
+    if name in _extension_exports:
+        import importlib
+
+        value = _extension_exports[name]
+        if isinstance(value, str):
+            module_path, _, attr_name = value.rpartition(".")
+            if module_path:
+                module = importlib.import_module(module_path)
+                return getattr(module, attr_name)
+            return importlib.import_module(value)
+        return value
+
    msg = f"module {__name__!r} has no attribute {name!r}"
    raise AttributeError(msg)
--- a/lib/crewai/src/crewai/events/event_bus.py
+++ b/lib/crewai/src/crewai/events/event_bus.py
@@ -227,6 +227,39 @@ class CrewAIEventsBus:

        return decorator

+    def off(
+        self,
+        event_type: type[BaseEvent],
+        handler: Callable[..., Any],
+    ) -> None:
+        """Unregister an event handler for a specific event type.
+
+        Args:
+            event_type: The event class to stop listening for
+            handler: The handler function to unregister
+        """
+        with self._rwlock.w_locked():
+            if event_type in self._sync_handlers:
+                existing_sync = self._sync_handlers[event_type]
+                if handler in existing_sync:
+                    self._sync_handlers[event_type] = existing_sync - {handler}
+                    if not self._sync_handlers[event_type]:
+                        del self._sync_handlers[event_type]
+
+            if event_type in self._async_handlers:
+                existing_async = self._async_handlers[event_type]
+                if handler in existing_async:
+                    self._async_handlers[event_type] = existing_async - {handler}
+                    if not self._async_handlers[event_type]:
+                        del self._async_handlers[event_type]
+
+            if event_type in self._handler_dependencies:
+                self._handler_dependencies[event_type].pop(handler, None)
+                if not self._handler_dependencies[event_type]:
+                    del self._handler_dependencies[event_type]
+
+            self._execution_plan_cache.pop(event_type, None)
+
    def _call_handlers(
        self,
        source: Any,
--- a/lib/crewai/src/crewai/events/listeners/tracing/utils.py
+++ b/lib/crewai/src/crewai/events/listeners/tracing/utils.py
@@ -1,3 +1,4 @@
+from collections.abc import Callable
 from contextvars import ContextVar, Token
 from datetime import datetime
 import getpass
@@ -26,6 +27,8 @@ logger = logging.getLogger(__name__)

 _tracing_enabled: ContextVar[bool | None] = ContextVar("_tracing_enabled", default=None)

+_first_time_trace_hook: Callable[[], bool] | None = None
+

 def should_enable_tracing(*, override: bool | None = None) -> bool:
    """Determine if tracing should be enabled.
@@ -407,10 +410,12 @@ def truncate_messages(
 def should_auto_collect_first_time_traces() -> bool:
    """True if we should auto-collect traces for first-time user.

-
    Returns:
        True if first-time user AND telemetry not disabled AND tracing not explicitly enabled, False otherwise.
    """
+    if _first_time_trace_hook is not None:
+        return _first_time_trace_hook()
+
    if _is_test_environment():
        return False

--- a/lib/crewai/src/crewai/events/types/tool_usage_events.py
+++ b/lib/crewai/src/crewai/events/types/tool_usage_events.py
@@ -16,7 +16,7 @@ class ToolUsageEvent(BaseEvent):
    tool_name: str
    tool_args: dict[str, Any] | str
    tool_class: str | None = None
-    run_attempts: int | None = None
+    run_attempts: int = 0
    delegations: int | None = None
    agent: Any | None = None
    task_name: str | None = None
@@ -26,7 +26,7 @@ class ToolUsageEvent(BaseEvent):

    model_config = ConfigDict(arbitrary_types_allowed=True)

-    def __init__(self, **data):
+    def __init__(self, **data: Any) -> None:
        if data.get("from_task"):
            task = data["from_task"]
            data["task_id"] = str(task.id)
@@ -96,10 +96,10 @@ class ToolExecutionErrorEvent(BaseEvent):
    type: str = "tool_execution_error"
    tool_name: str
    tool_args: dict[str, Any]
-    tool_class: Callable
+    tool_class: Callable[..., Any]
    agent: Any | None = None

-    def __init__(self, **data):
+    def __init__(self, **data: Any) -> None:
        super().__init__(**data)
        # Set fingerprint data from the agent
        if self.agent and hasattr(self.agent, "fingerprint") and self.agent.fingerprint:
--- a/lib/crewai/src/crewai/events/utils/console_formatter.py
+++ b/lib/crewai/src/crewai/events/utils/console_formatter.py
@@ -49,6 +49,9 @@ class ConsoleFormatter:
        if os.getenv("CI", "").lower() in ("true", "1"):
            return

+        if os.getenv("CREWAI_DISABLE_VERSION_CHECK", "").lower() in ("true", "1"):
+            return
+
        try:
            is_newer, current, latest = is_newer_version_available()
            if is_newer and latest:
--- a/lib/crewai/src/crewai/flow/async_feedback/init.py
+++ b/lib/crewai/src/crewai/flow/async_feedback/init.py
@@ -28,6 +28,8 @@ Example:
    ```
 """

+from typing import Any
+
 from crewai.flow.async_feedback.providers import ConsoleProvider
 from crewai.flow.async_feedback.types import (
    HumanFeedbackPending,
@@ -41,4 +43,15 @@ __all__ = [
    "HumanFeedbackPending",
    "HumanFeedbackProvider",
    "PendingFeedbackContext",
+    "_extension_exports",
 ]
+
+_extension_exports: dict[str, Any] = {}
+
+
+def __getattr__(name: str) -> Any:
+    """Support extensions via dynamic attribute lookup."""
+    if name in _extension_exports:
+        return _extension_exports[name]
+    msg = f"module {__name__!r} has no attribute {name!r}"
+    raise AttributeError(msg)
--- a/lib/crewai/src/crewai/knowledge/source/utils/init.py
+++ b/lib/crewai/src/crewai/knowledge/source/utils/init.py
@@ -0,0 +1 @@
+"""Knowledge source utilities."""
--- a/lib/crewai/src/crewai/knowledge/source/utils/source_helper.py
+++ b/lib/crewai/src/crewai/knowledge/source/utils/source_helper.py
@@ -0,0 +1,70 @@
+"""Helper utilities for knowledge sources."""
+
+from typing import Any, ClassVar
+
+from crewai.knowledge.source.base_knowledge_source import BaseKnowledgeSource
+from crewai.knowledge.source.csv_knowledge_source import CSVKnowledgeSource
+from crewai.knowledge.source.excel_knowledge_source import ExcelKnowledgeSource
+from crewai.knowledge.source.json_knowledge_source import JSONKnowledgeSource
+from crewai.knowledge.source.pdf_knowledge_source import PDFKnowledgeSource
+from crewai.knowledge.source.text_file_knowledge_source import TextFileKnowledgeSource
+
+
+class SourceHelper:
+    """Helper class for creating and managing knowledge sources."""
+
+    SUPPORTED_FILE_TYPES: ClassVar[list[str]] = [
+        ".csv",
+        ".pdf",
+        ".json",
+        ".txt",
+        ".xlsx",
+        ".xls",
+    ]
+
+    _FILE_TYPE_MAP: ClassVar[dict[str, type[BaseKnowledgeSource]]] = {
+        ".csv": CSVKnowledgeSource,
+        ".pdf": PDFKnowledgeSource,
+        ".json": JSONKnowledgeSource,
+        ".txt": TextFileKnowledgeSource,
+        ".xlsx": ExcelKnowledgeSource,
+        ".xls": ExcelKnowledgeSource,
+    }
+
+    @classmethod
+    def is_supported_file(cls, file_path: str) -> bool:
+        """Check if a file type is supported.
+
+        Args:
+            file_path: Path to the file.
+
+        Returns:
+            True if the file type is supported.
+        """
+        return file_path.lower().endswith(tuple(cls.SUPPORTED_FILE_TYPES))
+
+    @classmethod
+    def get_source(
+        cls, file_path: str, metadata: dict[str, Any] | None = None
+    ) -> BaseKnowledgeSource:
+        """Create appropriate KnowledgeSource based on file extension.
+
+        Args:
+            file_path: Path to the file.
+            metadata: Optional metadata to attach to the source.
+
+        Returns:
+            The appropriate KnowledgeSource instance.
+
+        Raises:
+            ValueError: If the file type is not supported.
+        """
+        if not cls.is_supported_file(file_path):
+            raise ValueError(f"Unsupported file type: {file_path}")
+
+        lower_path = file_path.lower()
+        for ext, source_cls in cls._FILE_TYPE_MAP.items():
+            if lower_path.endswith(ext):
+                return source_cls(file_path=[file_path], metadata=metadata)
+
+        raise ValueError(f"Unsupported file type: {file_path}")
--- a/lib/crewai/src/crewai/llms/providers/anthropic/completion.py
+++ b/lib/crewai/src/crewai/llms/providers/anthropic/completion.py
@@ -290,7 +290,7 @@ class AnthropicCompletion(BaseLLM):

                # Prepare completion parameters
                completion_params = self._prepare_completion_params(
-                    formatted_messages, system_message, tools
+                    formatted_messages, system_message, tools, available_functions
                )

                effective_response_model = response_model or self.response_format
@@ -361,7 +361,7 @@ class AnthropicCompletion(BaseLLM):
                )

                completion_params = self._prepare_completion_params(
-                    formatted_messages, system_message, tools
+                    formatted_messages, system_message, tools, available_functions
                )

                effective_response_model = response_model or self.response_format
@@ -396,6 +396,7 @@ class AnthropicCompletion(BaseLLM):
        messages: list[LLMMessage],
        system_message: str | None = None,
        tools: list[dict[str, Any]] | None = None,
+        available_functions: dict[str, Any] | None = None,
    ) -> dict[str, Any]:
        """Prepare parameters for Anthropic messages API.

@@ -403,6 +404,8 @@ class AnthropicCompletion(BaseLLM):
            messages: Formatted messages for Anthropic
            system_message: Extracted system message
            tools: Tool definitions
+            available_functions: Available functions for tool calling. When provided
+                with a single tool, tool_choice is automatically set to force tool use.

        Returns:
            Parameters dictionary for Anthropic API
@@ -428,7 +431,13 @@ class AnthropicCompletion(BaseLLM):

        # Handle tools for Claude 3+
        if tools and self.supports_tools:
-            params["tools"] = self._convert_tools_for_interference(tools)
+            converted_tools = self._convert_tools_for_interference(tools)
+            params["tools"] = converted_tools
+
+            if available_functions and len(converted_tools) == 1:
+                tool_name = converted_tools[0].get("name")
+                if tool_name and tool_name in available_functions:
+                    params["tool_choice"] = {"type": "tool", "name": tool_name}

        if self.thinking:
            if isinstance(self.thinking, AnthropicThinkingConfig):
@@ -730,15 +739,11 @@ class AnthropicCompletion(BaseLLM):
                    )
                    return list(tool_uses)

-                # Handle tool use conversation flow internally
-                return self._handle_tool_use_conversation(
-                    response,
-                    tool_uses,
-                    params,
-                    available_functions,
-                    from_task,
-                    from_agent,
+                result = self._execute_first_tool(
+                    tool_uses, available_functions, from_task, from_agent
                )
+                if result is not None:
+                    return result

        content = ""
        thinking_blocks: list[ThinkingBlock] = []
@@ -939,14 +944,12 @@ class AnthropicCompletion(BaseLLM):
                if not available_functions:
                    return list(tool_uses)

-                return self._handle_tool_use_conversation(
-                    final_message,
-                    tool_uses,
-                    params,
-                    available_functions,
-                    from_task,
-                    from_agent,
+                # Execute first tool and return result directly
+                result = self._execute_first_tool(
+                    tool_uses, available_functions, from_task, from_agent
                )
+                if result is not None:
+                    return result

        full_response = self._apply_stop_words(full_response)

@@ -1005,6 +1008,41 @@ class AnthropicCompletion(BaseLLM):

        return tool_results

+    def _execute_first_tool(
+        self,
+        tool_uses: list[ToolUseBlock | BetaToolUseBlock],
+        available_functions: dict[str, Any],
+        from_task: Any | None = None,
+        from_agent: Any | None = None,
+    ) -> Any | None:
+        """Execute the first tool from the tool_uses list and return its result.
+
+        This is used when available_functions is provided, to directly execute
+        the tool and return its result (matching OpenAI behavior for use cases
+        like reasoning_handler).
+
+        Args:
+            tool_uses: List of tool use blocks from Claude's response
+            available_functions: Available functions for tool calling
+            from_task: Task that initiated the call
+            from_agent: Agent that initiated the call
+
+        Returns:
+            The result of the first tool execution, or None if execution failed
+        """
+        tool_use = tool_uses[0]
+        function_name = tool_use.name
+        function_args = cast(dict[str, Any], tool_use.input)
+
+        return self._handle_tool_execution(
+            function_name=function_name,
+            function_args=function_args,
+            available_functions=available_functions,
+            from_task=from_task,
+            from_agent=from_agent,
+        )
+
+    # TODO: we drop this
    def _handle_tool_use_conversation(
        self,
        initial_response: Message | BetaMessage,
@@ -1220,14 +1258,11 @@ class AnthropicCompletion(BaseLLM):
                    )
                    return list(tool_uses)

-                return await self._ahandle_tool_use_conversation(
-                    response,
-                    tool_uses,
-                    params,
-                    available_functions,
-                    from_task,
-                    from_agent,
+                result = self._execute_first_tool(
+                    tool_uses, available_functions, from_task, from_agent
                )
+                if result is not None:
+                    return result

        content = ""
        if response.content:
@@ -1408,14 +1443,11 @@ class AnthropicCompletion(BaseLLM):
                if not available_functions:
                    return list(tool_uses)

-                return await self._ahandle_tool_use_conversation(
-                    final_message,
-                    tool_uses,
-                    params,
-                    available_functions,
-                    from_task,
-                    from_agent,
+                result = self._execute_first_tool(
+                    tool_uses, available_functions, from_task, from_agent
                )
+                if result is not None:
+                    return result

        full_response = self._apply_stop_words(full_response)

--- a/lib/crewai/src/crewai/task.py
+++ b/lib/crewai/src/crewai/task.py
@@ -31,6 +31,7 @@ from pydantic_core import PydanticCustomError
 from typing_extensions import Self

 from crewai.agents.agent_builder.base_agent import BaseAgent
+from crewai.core.providers.content_processor import process_content
 from crewai.events.event_bus import crewai_event_bus
 from crewai.events.types.task_events import (
    TaskCompletedEvent,
@@ -496,6 +497,7 @@ class Task(BaseModel):
        tools: list[BaseTool] | None = None,
    ) -> TaskOutput:
        """Execute the task synchronously."""
+        self.start_time = datetime.datetime.now()
        return self._execute_core(agent, context, tools)

    @property
@@ -536,6 +538,7 @@ class Task(BaseModel):
    ) -> None:
        """Execute the task asynchronously with context handling."""
        try:
+            self.start_time = datetime.datetime.now()
            result = self._execute_core(agent, context, tools)
            future.set_result(result)
        except Exception as e:
@@ -548,6 +551,7 @@ class Task(BaseModel):
        tools: list[BaseTool] | None = None,
    ) -> TaskOutput:
        """Execute the task asynchronously using native async/await."""
+        self.start_time = datetime.datetime.now()
        return await self._aexecute_core(agent, context, tools)

    async def _aexecute_core(
@@ -566,8 +570,6 @@ class Task(BaseModel):
                    f"The task '{self.description}' has no agent assigned, therefore it can't be executed directly and should be executed in a Crew using a specific process that support that, like hierarchical."
                )

-            self.start_time = datetime.datetime.now()
-
            self.prompt_context = context
            tools = tools or self.tools or []

@@ -579,6 +581,8 @@ class Task(BaseModel):
                tools=tools,
            )

+            self._post_agent_execution(agent)
+
            if not self._guardrails and not self._guardrail:
                pydantic_output, json_output = self._export_output(result)
            else:
@@ -661,8 +665,6 @@ class Task(BaseModel):
                    f"The task '{self.description}' has no agent assigned, therefore it can't be executed directly and should be executed in a Crew using a specific process that support that, like hierarchical."
                )

-            self.start_time = datetime.datetime.now()
-
            self.prompt_context = context
            tools = tools or self.tools or []

@@ -674,6 +676,8 @@ class Task(BaseModel):
                tools=tools,
            )

+            self._post_agent_execution(agent)
+
            if not self._guardrails and not self._guardrail:
                pydantic_output, json_output = self._export_output(result)
            else:
@@ -741,6 +745,9 @@ class Task(BaseModel):
        finally:
            clear_task_files(self.id)

+    def _post_agent_execution(self, agent: BaseAgent) -> None:
+        pass
+
    def prompt(self) -> str:
        """Generates the task prompt with optional markdown formatting.

@@ -863,6 +870,11 @@ Follow these guidelines:
        except ValueError as e:
            raise ValueError(f"Error interpolating description: {e!s}") from e

+        self.description = process_content(self.description, {"task": self})
+        self._original_expected_output = process_content(
+            self._original_expected_output, {"task": self}
+        )
+
        try:
            self.expected_output = interpolate_only(
                input_string=self._original_expected_output, inputs=inputs
--- a/lib/crewai/src/crewai/utilities/evaluators/crew_evaluator_handler.py
+++ b/lib/crewai/src/crewai/utilities/evaluators/crew_evaluator_handler.py
@@ -1,7 +1,7 @@
 from __future__ import annotations

 from collections import defaultdict
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any

 from pydantic import BaseModel, Field, InstanceOf
 from rich.box import HEAVY_EDGE
@@ -36,7 +36,13 @@ class CrewEvaluator:
        iteration: The current iteration of the evaluation.
    """

-    def __init__(self, crew: Crew, eval_llm: InstanceOf[BaseLLM]) -> None:
+    def __init__(
+        self,
+        crew: Crew,
+        eval_llm: InstanceOf[BaseLLM] | str | None = None,
+        openai_model_name: str | None = None,
+        llm: InstanceOf[BaseLLM] | str | None = None,
+    ) -> None:
        self.crew = crew
        self.llm = eval_llm
        self.tasks_scores: defaultdict[int, list[float]] = defaultdict(list)
@@ -86,7 +92,9 @@ class CrewEvaluator:
        """
        self.iteration = iteration

-    def print_crew_evaluation_result(self) -> None:
+    def print_crew_evaluation_result(
+        self, token_usage: list[dict[str, Any]] | None = None
+    ) -> None:
        """
        Prints the evaluation result of the crew in a table.
        A Crew with 2 tasks using the command crewai test -n 3
@@ -204,7 +212,7 @@ class CrewEvaluator:
                CrewTestResultEvent(
                    quality=quality_score,
                    execution_duration=current_task.execution_duration,
-                    model=self.llm.model,
+                    model=getattr(self.llm, "model", str(self.llm)),
                    crew_name=self.crew.name,
                    crew=self.crew,
                ),
--- a/lib/crewai/src/crewai/utilities/pydantic_schema_utils.py
+++ b/lib/crewai/src/crewai/utilities/pydantic_schema_utils.py
@@ -19,9 +19,10 @@ from collections.abc import Callable
 from copy import deepcopy
 import datetime
 import logging
-from typing import TYPE_CHECKING, Annotated, Any, Literal, Union
+from typing import TYPE_CHECKING, Annotated, Any, Final, Literal, TypedDict, Union
 import uuid

+import jsonref  # type: ignore[import-untyped]
 from pydantic import (
    UUID1,
    UUID3,
@@ -69,6 +70,21 @@ else:
        EmailStr = str


+class JsonSchemaInfo(TypedDict):
+    """Inner structure for JSON schema metadata."""
+
+    name: str
+    strict: Literal[True]
+    schema: dict[str, Any]
+
+
+class ModelDescription(TypedDict):
+    """Return type for generate_model_description."""
+
+    type: Literal["json_schema"]
+    json_schema: JsonSchemaInfo
+
+
 def resolve_refs(schema: dict[str, Any]) -> dict[str, Any]:
    """Recursively resolve all local $refs in the given JSON Schema using $defs as the source.

@@ -157,6 +173,72 @@ def force_additional_properties_false(d: Any) -> Any:
    return d


+OPENAI_SUPPORTED_FORMATS: Final[
+    set[Literal["date-time", "date", "time", "duration"]]
+] = {
+    "date-time",
+    "date",
+    "time",
+    "duration",
+}
+
+
+def strip_unsupported_formats(d: Any) -> Any:
+    """Remove format annotations that OpenAI strict mode doesn't support.
+
+    OpenAI only supports: date-time, date, time, duration.
+    Other formats like uri, email, uuid etc. cause validation errors.
+
+    Args:
+        d: The dictionary/list to modify.
+
+    Returns:
+        The modified dictionary/list.
+    """
+    if isinstance(d, dict):
+        format_value = d.get("format")
+        if (
+            isinstance(format_value, str)
+            and format_value not in OPENAI_SUPPORTED_FORMATS
+        ):
+            del d["format"]
+        for v in d.values():
+            strip_unsupported_formats(v)
+    elif isinstance(d, list):
+        for i in d:
+            strip_unsupported_formats(i)
+    return d
+
+
+def ensure_type_in_schemas(d: Any) -> Any:
+    """Ensure all schema objects in anyOf/oneOf have a 'type' key.
+
+    OpenAI strict mode requires every schema to have a 'type' key.
+    Empty schemas {} in anyOf/oneOf are converted to {"type": "object"}.
+
+    Args:
+        d: The dictionary/list to modify.
+
+    Returns:
+        The modified dictionary/list.
+    """
+    if isinstance(d, dict):
+        for key in ("anyOf", "oneOf"):
+            if key in d:
+                schema_list = d[key]
+                for i, schema in enumerate(schema_list):
+                    if isinstance(schema, dict) and schema == {}:
+                        schema_list[i] = {"type": "object"}
+                    else:
+                        ensure_type_in_schemas(schema)
+        for v in d.values():
+            ensure_type_in_schemas(v)
+    elif isinstance(d, list):
+        for item in d:
+            ensure_type_in_schemas(item)
+    return d
+
+
 def fix_discriminator_mappings(schema: dict[str, Any]) -> dict[str, Any]:
    """Replace '#/$defs/...' references in discriminator.mapping with just the model name.

@@ -293,7 +375,49 @@ def ensure_all_properties_required(schema: dict[str, Any]) -> dict[str, Any]:
    return schema


-def generate_model_description(model: type[BaseModel]) -> dict[str, Any]:
+def strip_null_from_types(schema: dict[str, Any]) -> dict[str, Any]:
+    """Remove null type from anyOf/type arrays.
+
+    Pydantic generates `T | None` for optional fields, which creates schemas with
+    null in the type. However, for MCP tools, optional fields should be omitted
+    entirely rather than sent as null. This function strips null from types.
+
+    Args:
+        schema: JSON schema dictionary.
+
+    Returns:
+        Modified schema with null types removed.
+    """
+    if isinstance(schema, dict):
+        if "anyOf" in schema:
+            any_of = schema["anyOf"]
+            non_null = [opt for opt in any_of if opt.get("type") != "null"]
+            if len(non_null) == 1:
+                schema.pop("anyOf")
+                schema.update(non_null[0])
+            elif len(non_null) > 1:
+                schema["anyOf"] = non_null
+
+        type_value = schema.get("type")
+        if isinstance(type_value, list) and "null" in type_value:
+            non_null_types = [t for t in type_value if t != "null"]
+            if len(non_null_types) == 1:
+                schema["type"] = non_null_types[0]
+            elif len(non_null_types) > 1:
+                schema["type"] = non_null_types
+
+        for value in schema.values():
+            if isinstance(value, dict):
+                strip_null_from_types(value)
+            elif isinstance(value, list):
+                for item in value:
+                    if isinstance(item, dict):
+                        strip_null_from_types(item)
+
+    return schema
+
+
+def generate_model_description(model: type[BaseModel]) -> ModelDescription:
    """Generate JSON schema description of a Pydantic model.

    This function takes a Pydantic model class and returns its JSON schema,
@@ -304,11 +428,13 @@ def generate_model_description(model: type[BaseModel]) -> dict[str, Any]:
        model: A Pydantic model class.

    Returns:
-        A JSON schema dictionary representation of the model.
+        A ModelDescription with JSON schema representation of the model.
    """
    json_schema = model.model_json_schema(ref_template="#/$defs/{model}")

    json_schema = force_additional_properties_false(json_schema)
+    json_schema = strip_unsupported_formats(json_schema)
+    json_schema = ensure_type_in_schemas(json_schema)

    json_schema = resolve_refs(json_schema)

@@ -316,6 +442,7 @@ def generate_model_description(model: type[BaseModel]) -> dict[str, Any]:
    json_schema = fix_discriminator_mappings(json_schema)
    json_schema = convert_oneof_to_anyof(json_schema)
    json_schema = ensure_all_properties_required(json_schema)
+    json_schema = strip_null_from_types(json_schema)

    return {
        "type": "json_schema",
@@ -400,6 +527,8 @@ def create_model_from_schema(  # type: ignore[no-any-unimported]
        >>> person.name
        'John'
    """
+    json_schema = dict(jsonref.replace_refs(json_schema, proxies=False))
+
    effective_root = root_schema or json_schema

    json_schema = force_additional_properties_false(json_schema)
@@ -410,7 +539,7 @@ def create_model_from_schema(  # type: ignore[no-any-unimported]
        if "title" not in json_schema and "title" in (root_schema or {}):
            json_schema["title"] = (root_schema or {}).get("title")

-    model_name = json_schema.get("title", "DynamicModel")
+    model_name = json_schema.get("title") or "DynamicModel"
    field_definitions = {
        name: _json_schema_to_pydantic_field(
            name, prop, json_schema.get("required", []), effective_root
@@ -418,9 +547,11 @@ def create_model_from_schema(  # type: ignore[no-any-unimported]
        for name, prop in (json_schema.get("properties", {}) or {}).items()
    }

+    effective_config = __config__ or ConfigDict(extra="forbid")
+
    return create_model_base(
        model_name,
-        __config__=__config__,
+        __config__=effective_config,
        __base__=__base__,
        __module__=__module__,
        __validators__=__validators__,
@@ -599,8 +730,10 @@ def _json_schema_to_pydantic_type(
        any_of_schemas = json_schema.get("anyOf", []) + json_schema.get("oneOf", [])
    if any_of_schemas:
        any_of_types = [
-            _json_schema_to_pydantic_type(schema, root_schema)
-            for schema in any_of_schemas
+            _json_schema_to_pydantic_type(
+                schema, root_schema, name_=f"{name_ or 'Union'}Option{i}"
+            )
+            for i, schema in enumerate(any_of_schemas)
        ]
        return Union[tuple(any_of_types)]  # noqa: UP007

@@ -636,7 +769,7 @@ def _json_schema_to_pydantic_type(
        if properties:
            json_schema_ = json_schema.copy()
            if json_schema_.get("title") is None:
-                json_schema_["title"] = name_
+                json_schema_["title"] = name_ or "DynamicModel"
            return create_model_from_schema(json_schema_, root_schema=root_schema)
        return dict
    if type_ == "null":
--- a/lib/crewai/tests/agents/test_agent.py
+++ b/lib/crewai/tests/agents/test_agent.py
@@ -703,6 +703,8 @@ def test_agent_definition_based_on_dict():
 # test for human input
@pytest.mark.vcr()
 def test_agent_human_input():
+    from crewai.core.providers.human_input import SyncHumanInputProvider
+
    # Agent configuration
    config = {
        "role": "test role",
@@ -720,7 +722,7 @@ def test_agent_human_input():
        human_input=True,
    )

-    # Side effect function for _ask_human_input to simulate multiple feedback iterations
+    # Side effect function for _prompt_input to simulate multiple feedback iterations
    feedback_responses = iter(
        [
            "Don't say hi, say Hello instead!",  # First feedback: instruct change
@@ -728,16 +730,16 @@ def test_agent_human_input():
        ]
    )

-    def ask_human_input_side_effect(*args, **kwargs):
+    def prompt_input_side_effect(*args, **kwargs):
        return next(feedback_responses)

-    # Patch both _ask_human_input and _invoke_loop to avoid real API/network calls.
+    # Patch both _prompt_input on provider and _invoke_loop to avoid real API/network calls.
    with (
        patch.object(
-            CrewAgentExecutor,
-            "_ask_human_input",
-            side_effect=ask_human_input_side_effect,
-        ) as mock_human_input,
+            SyncHumanInputProvider,
+            "_prompt_input",
+            side_effect=prompt_input_side_effect,
+        ) as mock_prompt_input,
        patch.object(
            CrewAgentExecutor,
            "_invoke_loop",
@@ -749,7 +751,7 @@ def test_agent_human_input():

        # Assertions to ensure the agent behaves correctly.
        # It should have requested feedback twice.
-        assert mock_human_input.call_count == 2
+        assert mock_prompt_input.call_count == 2
        # The final result should be processed to "Hello"
        assert output.strip().lower() == "hello"

--- a/lib/crewai/tests/cassettes/llms/anthropic/test_anthropic_tool_execution_returns_tool_result_directly.yaml
+++ b/lib/crewai/tests/cassettes/llms/anthropic/test_anthropic_tool_execution_returns_tool_result_directly.yaml
@@ -0,0 +1,102 @@
+interactions:
+- request:
+    body: '{"max_tokens":4096,"messages":[{"role":"user","content":"Calculate 5 +
+      3 using the simple_calculator tool with operation ''add''."}],"model":"claude-3-5-haiku-20241022","stream":false,"tool_choice":{"type":"tool","name":"simple_calculator"},"tools":[{"name":"simple_calculator","description":"Perform
+      simple math operations","input_schema":{"type":"object","properties":{"operation":{"type":"string","enum":["add","multiply"],"description":"The
+      operation to perform"},"a":{"type":"integer","description":"First number"},"b":{"type":"integer","description":"Second
+      number"}},"required":["operation","a","b"]}}]}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - ACCEPT-ENCODING-XXX
+      anthropic-version:
+      - '2023-06-01'
+      connection:
+      - keep-alive
+      content-length:
+      - '608'
+      content-type:
+      - application/json
+      host:
+      - api.anthropic.com
+      user-agent:
+      - X-USER-AGENT-XXX
+      x-stainless-arch:
+      - X-STAINLESS-ARCH-XXX
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - X-STAINLESS-OS-XXX
+      x-stainless-package-version:
+      - 0.73.0
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+      x-stainless-timeout:
+      - NOT_GIVEN
+    method: POST
+    uri: https://api.anthropic.com/v1/messages
+  response:
+    body:
+      string: '{"model":"claude-3-5-haiku-20241022","id":"msg_01Q2F83aAeqqTCxsd8WpZjK7","type":"message","role":"assistant","content":[{"type":"tool_use","id":"toolu_01BW4XkHnhRVM5JZsvoaQKw5","name":"simple_calculator","input":{"operation":"add","a":5,"b":3}}],"stop_reason":"tool_use","stop_sequence":null,"usage":{"input_tokens":498,"cache_creation_input_tokens":0,"cache_read_input_tokens":0,"cache_creation":{"ephemeral_5m_input_tokens":0,"ephemeral_1h_input_tokens":0},"output_tokens":67,"service_tier":"standard"}}'
+    headers:
+      CF-RAY:
+      - CF-RAY-XXX
+      Connection:
+      - keep-alive
+      Content-Security-Policy:
+      - CSP-FILTERED
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 03 Feb 2026 23:26:35 GMT
+      Server:
+      - cloudflare
+      Transfer-Encoding:
+      - chunked
+      X-Robots-Tag:
+      - none
+      anthropic-organization-id:
+      - ANTHROPIC-ORGANIZATION-ID-XXX
+      anthropic-ratelimit-input-tokens-limit:
+      - ANTHROPIC-RATELIMIT-INPUT-TOKENS-LIMIT-XXX
+      anthropic-ratelimit-input-tokens-remaining:
+      - ANTHROPIC-RATELIMIT-INPUT-TOKENS-REMAINING-XXX
+      anthropic-ratelimit-input-tokens-reset:
+      - ANTHROPIC-RATELIMIT-INPUT-TOKENS-RESET-XXX
+      anthropic-ratelimit-output-tokens-limit:
+      - ANTHROPIC-RATELIMIT-OUTPUT-TOKENS-LIMIT-XXX
+      anthropic-ratelimit-output-tokens-remaining:
+      - ANTHROPIC-RATELIMIT-OUTPUT-TOKENS-REMAINING-XXX
+      anthropic-ratelimit-output-tokens-reset:
+      - ANTHROPIC-RATELIMIT-OUTPUT-TOKENS-RESET-XXX
+      anthropic-ratelimit-requests-limit:
+      - '4000'
+      anthropic-ratelimit-requests-remaining:
+      - '3999'
+      anthropic-ratelimit-requests-reset:
+      - '2026-02-03T23:26:34Z'
+      anthropic-ratelimit-tokens-limit:
+      - ANTHROPIC-RATELIMIT-TOKENS-LIMIT-XXX
+      anthropic-ratelimit-tokens-remaining:
+      - ANTHROPIC-RATELIMIT-TOKENS-REMAINING-XXX
+      anthropic-ratelimit-tokens-reset:
+      - ANTHROPIC-RATELIMIT-TOKENS-RESET-XXX
+      cf-cache-status:
+      - DYNAMIC
+      request-id:
+      - REQUEST-ID-XXX
+      strict-transport-security:
+      - STS-XXX
+      x-envoy-upstream-service-time:
+      - '1228'
+    status:
+      code: 200
+      message: OK
+version: 1
--- a/lib/crewai/tests/cassettes/llms/anthropic/test_anthropic_tool_execution_with_available_functions.yaml
+++ b/lib/crewai/tests/cassettes/llms/anthropic/test_anthropic_tool_execution_with_available_functions.yaml
@@ -0,0 +1,108 @@
+interactions:
+- request:
+    body: '{"max_tokens":4096,"messages":[{"role":"user","content":"Create a simple
+      plan to say hello. Use the create_reasoning_plan tool."}],"model":"claude-3-5-haiku-20241022","stream":false,"tool_choice":{"type":"tool","name":"create_reasoning_plan"},"tools":[{"name":"create_reasoning_plan","description":"Create
+      a structured reasoning plan for completing a task","input_schema":{"type":"object","properties":{"plan":{"type":"string","description":"High-level
+      plan description"},"steps":{"type":"array","items":{"type":"object"},"description":"List
+      of steps to execute"},"ready":{"type":"boolean","description":"Whether the plan
+      is ready to execute"}},"required":["plan","steps","ready"]}}]}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - ACCEPT-ENCODING-XXX
+      anthropic-version:
+      - '2023-06-01'
+      connection:
+      - keep-alive
+      content-length:
+      - '684'
+      content-type:
+      - application/json
+      host:
+      - api.anthropic.com
+      user-agent:
+      - X-USER-AGENT-XXX
+      x-stainless-arch:
+      - X-STAINLESS-ARCH-XXX
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - X-STAINLESS-OS-XXX
+      x-stainless-package-version:
+      - 0.73.0
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+      x-stainless-timeout:
+      - NOT_GIVEN
+    method: POST
+    uri: https://api.anthropic.com/v1/messages
+  response:
+    body:
+      string: '{"model":"claude-3-5-haiku-20241022","id":"msg_01HLuGgGRFseMdhTYAhkKtfz","type":"message","role":"assistant","content":[{"type":"tool_use","id":"toolu_01GQAUFHffGzMd3ufA6YRMZF","name":"create_reasoning_plan","input":{"plan":"Say
+        hello in a friendly and straightforward manner","steps":[{"description":"Take
+        a deep breath","action":"Pause and relax"},{"description":"Smile","action":"Prepare
+        a warm facial expression"},{"description":"Greet the person","action":"Say
+        ''Hello!''"},{"description":"Wait for response","action":"Listen and be ready
+        to continue conversation"}],"ready":true}}],"stop_reason":"tool_use","stop_sequence":null,"usage":{"input_tokens":513,"cache_creation_input_tokens":0,"cache_read_input_tokens":0,"cache_creation":{"ephemeral_5m_input_tokens":0,"ephemeral_1h_input_tokens":0},"output_tokens":162,"service_tier":"standard"}}'
+    headers:
+      CF-RAY:
+      - CF-RAY-XXX
+      Connection:
+      - keep-alive
+      Content-Security-Policy:
+      - CSP-FILTERED
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 03 Feb 2026 23:26:38 GMT
+      Server:
+      - cloudflare
+      Transfer-Encoding:
+      - chunked
+      X-Robots-Tag:
+      - none
+      anthropic-organization-id:
+      - ANTHROPIC-ORGANIZATION-ID-XXX
+      anthropic-ratelimit-input-tokens-limit:
+      - ANTHROPIC-RATELIMIT-INPUT-TOKENS-LIMIT-XXX
+      anthropic-ratelimit-input-tokens-remaining:
+      - ANTHROPIC-RATELIMIT-INPUT-TOKENS-REMAINING-XXX
+      anthropic-ratelimit-input-tokens-reset:
+      - ANTHROPIC-RATELIMIT-INPUT-TOKENS-RESET-XXX
+      anthropic-ratelimit-output-tokens-limit:
+      - ANTHROPIC-RATELIMIT-OUTPUT-TOKENS-LIMIT-XXX
+      anthropic-ratelimit-output-tokens-remaining:
+      - ANTHROPIC-RATELIMIT-OUTPUT-TOKENS-REMAINING-XXX
+      anthropic-ratelimit-output-tokens-reset:
+      - ANTHROPIC-RATELIMIT-OUTPUT-TOKENS-RESET-XXX
+      anthropic-ratelimit-requests-limit:
+      - '4000'
+      anthropic-ratelimit-requests-remaining:
+      - '3999'
+      anthropic-ratelimit-requests-reset:
+      - '2026-02-03T23:26:35Z'
+      anthropic-ratelimit-tokens-limit:
+      - ANTHROPIC-RATELIMIT-TOKENS-LIMIT-XXX
+      anthropic-ratelimit-tokens-remaining:
+      - ANTHROPIC-RATELIMIT-TOKENS-REMAINING-XXX
+      anthropic-ratelimit-tokens-reset:
+      - ANTHROPIC-RATELIMIT-TOKENS-RESET-XXX
+      cf-cache-status:
+      - DYNAMIC
+      request-id:
+      - REQUEST-ID-XXX
+      strict-transport-security:
+      - STS-XXX
+      x-envoy-upstream-service-time:
+      - '2994'
+    status:
+      code: 200
+      message: OK
+version: 1
--- a/lib/crewai/tests/llms/anthropic/test_anthropic.py
+++ b/lib/crewai/tests/llms/anthropic/test_anthropic.py
@@ -45,85 +45,6 @@ def test_anthropic_completion_is_used_when_claude_provider():



-def test_anthropic_tool_use_conversation_flow():
-    """
-    Test that the Anthropic completion properly handles tool use conversation flow
-    """
-    from unittest.mock import Mock, patch
-    from crewai.llms.providers.anthropic.completion import AnthropicCompletion
-    from anthropic.types.tool_use_block import ToolUseBlock
-
-    # Create AnthropicCompletion instance
-    completion = AnthropicCompletion(model="claude-3-5-sonnet-20241022")
-
-    # Mock tool function
-    def mock_weather_tool(location: str) -> str:
-        return f"The weather in {location} is sunny and 75°F"
-
-    available_functions = {"get_weather": mock_weather_tool}
-
-    # Mock the Anthropic client responses
-    with patch.object(completion.client.messages, 'create') as mock_create:
-        # Mock initial response with tool use - need to properly mock ToolUseBlock
-        mock_tool_use = Mock(spec=ToolUseBlock)
-        mock_tool_use.type = "tool_use"
-        mock_tool_use.id = "tool_123"
-        mock_tool_use.name = "get_weather"
-        mock_tool_use.input = {"location": "San Francisco"}
-
-        mock_initial_response = Mock()
-        mock_initial_response.content = [mock_tool_use]
-        mock_initial_response.usage = Mock()
-        mock_initial_response.usage.input_tokens = 100
-        mock_initial_response.usage.output_tokens = 50
-
-        # Mock final response after tool result - properly mock text content
-        mock_text_block = Mock()
-        mock_text_block.type = "text"
-        # Set the text attribute as a string, not another Mock
-        mock_text_block.configure_mock(text="Based on the weather data, it's a beautiful day in San Francisco with sunny skies and 75°F temperature.")
-
-        mock_final_response = Mock()
-        mock_final_response.content = [mock_text_block]
-        mock_final_response.usage = Mock()
-        mock_final_response.usage.input_tokens = 150
-        mock_final_response.usage.output_tokens = 75
-
-        # Configure mock to return different responses on successive calls
-        mock_create.side_effect = [mock_initial_response, mock_final_response]
-
-        # Test the call
-        messages = [{"role": "user", "content": "What's the weather like in San Francisco?"}]
-        result = completion.call(
-            messages=messages,
-            available_functions=available_functions
-        )
-
-        # Verify the result contains the final response
-        assert "beautiful day in San Francisco" in result
-        assert "sunny skies" in result
-        assert "75°F" in result
-
-        # Verify that two API calls were made (initial + follow-up)
-        assert mock_create.call_count == 2
-
-        # Verify the second call includes tool results
-        second_call_args = mock_create.call_args_list[1][1]  # kwargs of second call
-        messages_in_second_call = second_call_args["messages"]
-
-        # Should have original user message + assistant tool use + user tool result
-        assert len(messages_in_second_call) == 3
-        assert messages_in_second_call[0]["role"] == "user"
-        assert messages_in_second_call[1]["role"] == "assistant"
-        assert messages_in_second_call[2]["role"] == "user"
-
-        # Verify tool result format
-        tool_result = messages_in_second_call[2]["content"][0]
-        assert tool_result["type"] == "tool_result"
-        assert tool_result["tool_use_id"] == "tool_123"
-        assert "sunny and 75°F" in tool_result["content"]
-
-
 def test_anthropic_completion_module_is_imported():
    """
    Test that the completion module is properly imported when using Anthropic provider
@@ -874,6 +795,125 @@ def test_anthropic_function_calling():
 # =============================================================================


+@pytest.mark.vcr(filter_headers=["authorization", "x-api-key"])
+def test_anthropic_tool_execution_with_available_functions():
+    """
+    Test that Anthropic provider correctly executes tools when available_functions is provided.
+
+    This specifically tests the fix for double llm_call_completed emission - when
+    available_functions is provided, _handle_tool_execution is called which already
+    emits llm_call_completed, so the caller should not emit it again.
+
+    The test verifies:
+    1. The tool is called with correct arguments
+    2. The tool result is returned directly (not wrapped in conversation)
+    3. The result is valid JSON matching the tool output format
+    """
+    import json
+
+    llm = LLM(model="anthropic/claude-3-5-haiku-20241022")
+
+    # Simple tool that returns a formatted string
+    def create_reasoning_plan(plan: str, steps: list, ready: bool) -> str:
+        """Create a reasoning plan with steps."""
+        return json.dumps({"plan": plan, "steps": steps, "ready": ready})
+
+    tools = [
+        {
+            "name": "create_reasoning_plan",
+            "description": "Create a structured reasoning plan for completing a task",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "plan": {
+                        "type": "string",
+                        "description": "High-level plan description"
+                    },
+                    "steps": {
+                        "type": "array",
+                        "items": {"type": "object"},
+                        "description": "List of steps to execute"
+                    },
+                    "ready": {
+                        "type": "boolean",
+                        "description": "Whether the plan is ready to execute"
+                    }
+                },
+                "required": ["plan", "steps", "ready"]
+            }
+        }
+    ]
+
+    result = llm.call(
+        messages=[{"role": "user", "content": "Create a simple plan to say hello. Use the create_reasoning_plan tool."}],
+        tools=tools,
+        available_functions={"create_reasoning_plan": create_reasoning_plan}
+    )
+
+    # Verify result is valid JSON from the tool
+    assert result is not None
+    assert isinstance(result, str)
+
+    # Parse the result to verify it's valid JSON
+    parsed_result = json.loads(result)
+    assert "plan" in parsed_result
+    assert "steps" in parsed_result
+    assert "ready" in parsed_result
+
+
+@pytest.mark.vcr(filter_headers=["authorization", "x-api-key"])
+def test_anthropic_tool_execution_returns_tool_result_directly():
+    """
+    Test that when available_functions is provided, the tool result is returned directly
+    without additional LLM conversation (matching OpenAI behavior for reasoning_handler).
+    """
+    llm = LLM(model="anthropic/claude-3-5-haiku-20241022")
+
+    call_count = 0
+
+    def simple_calculator(operation: str, a: int, b: int) -> str:
+        """Perform a simple calculation."""
+        nonlocal call_count
+        call_count += 1
+        if operation == "add":
+            return str(a + b)
+        elif operation == "multiply":
+            return str(a * b)
+        return "Unknown operation"
+
+    tools = [
+        {
+            "name": "simple_calculator",
+            "description": "Perform simple math operations",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "operation": {
+                        "type": "string",
+                        "enum": ["add", "multiply"],
+                        "description": "The operation to perform"
+                    },
+                    "a": {"type": "integer", "description": "First number"},
+                    "b": {"type": "integer", "description": "Second number"}
+                },
+                "required": ["operation", "a", "b"]
+            }
+        }
+    ]
+
+    result = llm.call(
+        messages=[{"role": "user", "content": "Calculate 5 + 3 using the simple_calculator tool with operation 'add'."}],
+        tools=tools,
+        available_functions={"simple_calculator": simple_calculator}
+    )
+
+    # Tool should have been called exactly once
+    assert call_count == 1, f"Expected tool to be called once, got {call_count}"
+
+    # Result should be the direct tool output
+    assert result == "8", f"Expected '8' but got '{result}'"
+
+
@pytest.mark.vcr()
 def test_anthropic_agent_kickoff_structured_output_without_tools():
    """
--- a/lib/crewai/tests/test_flow_human_input_integration.py
+++ b/lib/crewai/tests/test_flow_human_input_integration.py
@@ -2,6 +2,7 @@ from unittest.mock import MagicMock, patch

 import pytest
 from crewai.events.event_listener import event_listener
+from crewai.core.providers.human_input import SyncHumanInputProvider


 class TestFlowHumanInputIntegration:
@@ -24,14 +25,9 @@ class TestFlowHumanInputIntegration:
    @patch("builtins.input", return_value="")
    def test_human_input_pauses_flow_updates(self, mock_input):
        """Test that human input pauses Flow status updates."""
-        from crewai.agents.agent_builder.base_agent_executor_mixin import (
-            CrewAgentExecutorMixin,
-        )
-
-        executor = CrewAgentExecutorMixin()
-        executor.crew = MagicMock()
-        executor.crew._train = False
-        executor._printer = MagicMock()
+        provider = SyncHumanInputProvider()
+        crew = MagicMock()
+        crew._train = False

        formatter = event_listener.formatter

@@ -39,7 +35,7 @@ class TestFlowHumanInputIntegration:
            patch.object(formatter, "pause_live_updates") as mock_pause,
            patch.object(formatter, "resume_live_updates") as mock_resume,
        ):
-            result = executor._ask_human_input("Test result")
+            result = provider._prompt_input(crew)

            mock_pause.assert_called_once()
            mock_resume.assert_called_once()
@@ -49,14 +45,9 @@ class TestFlowHumanInputIntegration:
    @patch("builtins.input", side_effect=["feedback", ""])
    def test_multiple_human_input_rounds(self, mock_input):
        """Test multiple rounds of human input with Flow status management."""
-        from crewai.agents.agent_builder.base_agent_executor_mixin import (
-            CrewAgentExecutorMixin,
-        )
-
-        executor = CrewAgentExecutorMixin()
-        executor.crew = MagicMock()
-        executor.crew._train = False
-        executor._printer = MagicMock()
+        provider = SyncHumanInputProvider()
+        crew = MagicMock()
+        crew._train = False

        formatter = event_listener.formatter

@@ -75,10 +66,10 @@ class TestFlowHumanInputIntegration:
                formatter, "resume_live_updates", side_effect=track_resume
            ),
        ):
-            result1 = executor._ask_human_input("Test result 1")
+            result1 = provider._prompt_input(crew)
            assert result1 == "feedback"

-            result2 = executor._ask_human_input("Test result 2")
+            result2 = provider._prompt_input(crew)
            assert result2 == ""

            assert len(pause_calls) == 2
@@ -103,14 +94,9 @@ class TestFlowHumanInputIntegration:

    def test_pause_resume_exception_handling(self):
        """Test that resume is called even if exception occurs during human input."""
-        from crewai.agents.agent_builder.base_agent_executor_mixin import (
-            CrewAgentExecutorMixin,
-        )
-
-        executor = CrewAgentExecutorMixin()
-        executor.crew = MagicMock()
-        executor.crew._train = False
-        executor._printer = MagicMock()
+        provider = SyncHumanInputProvider()
+        crew = MagicMock()
+        crew._train = False

        formatter = event_listener.formatter

@@ -122,21 +108,16 @@ class TestFlowHumanInputIntegration:
            ),
        ):
            with pytest.raises(KeyboardInterrupt):
-                executor._ask_human_input("Test result")
+                provider._prompt_input(crew)

            mock_pause.assert_called_once()
            mock_resume.assert_called_once()

    def test_training_mode_human_input(self):
        """Test human input in training mode."""
-        from crewai.agents.agent_builder.base_agent_executor_mixin import (
-            CrewAgentExecutorMixin,
-        )
-
-        executor = CrewAgentExecutorMixin()
-        executor.crew = MagicMock()
-        executor.crew._train = True
-        executor._printer = MagicMock()
+        provider = SyncHumanInputProvider()
+        crew = MagicMock()
+        crew._train = True

        formatter = event_listener.formatter

@@ -146,7 +127,7 @@ class TestFlowHumanInputIntegration:
            patch.object(formatter.console, "print") as mock_console_print,
            patch("builtins.input", return_value="training feedback"),
        ):
-            result = executor._ask_human_input("Test result")
+            result = provider._prompt_input(crew)

            mock_pause.assert_called_once()
            mock_resume.assert_called_once()
@@ -161,4 +142,4 @@ class TestFlowHumanInputIntegration:
                for call in call_args
                if call[0]
            )
-            assert training_panel_found
+            assert training_panel_found
Author	SHA1	Message	Date
Greyson LaLonde	d86d43d3e0	chore: refactor crew to provider Some checks are pending CodeQL Advanced / Analyze (actions) (push) Waiting to run Details CodeQL Advanced / Analyze (python) (push) Waiting to run Details Notify Downstream / notify-downstream (push) Waiting to run Details Enable dynamic extension exports and small behavior fixes across events and flow modules: - events/__init__.py: Added _extension_exports and extended __getattr__ to lazily resolve registered extension values or import paths. - events/event_bus.py: Implemented off() to unregister sync/async handlers, clean handler dependencies, and invalidate execution plan cache. - events/listeners/tracing/utils.py: Added Callable import and _first_time_trace_hook to allow overriding first-time trace auto-collection behavior. - events/types/tool_usage_events.py: Changed ToolUsageEvent.run_attempts default from None to 0 to avoid nullable handling. - events/utils/console_formatter.py: Respect CREWAI_DISABLE_VERSION_CHECK env var to skip version checks in CI-like flows. - flow/async_feedback/__init__.py: Added typing.Any import, _extension_exports and __getattr__ to support extensions via attribute lookup. These changes add extension points and safer defaults, and provide a way to unregister event handlers.	2026-02-04 16:05:21 -05:00
Greyson LaLonde	6bfc98e960	refactor: extract hitl to provider pattern * refactor: extract hitl to provider pattern - add humaninputprovider protocol with setup_messages and handle_feedback - move sync hitl logic from executor to synchuman inputprovider - add _passthrough_exceptions extension point in agent/core.py - create crewai.core.providers module for extensible components - remove _ask_human_input from base_agent_executor_mixin	2026-02-04 15:40:22 -05:00
Greyson LaLonde	3cc33ef6ab	fix: resolve complex schema $ref pointers in mcp tools Some checks failed CodeQL Advanced / Analyze (actions) (push) Has been cancelled Details CodeQL Advanced / Analyze (python) (push) Has been cancelled Details Notify Downstream / notify-downstream (push) Has been cancelled Details * fix: resolve complex schema $ref pointers in mcp tools * chore: update tool specifications * fix: adapt mcp tools; sanitize pydantic json schemas * fix: strip nulls from json schemas and simplify mcp args --------- Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>	2026-02-03 20:47:58 -05:00
Lorenze Jay	3fec4669af	Lorenze/fix/anthropic available functions call (#4360 ) * feat: enhance AnthropicCompletion to support available functions in tool execution - Updated the `_prepare_completion_params` method to accept `available_functions` for better tool handling. - Modified tool execution logic to directly return results from tools when `available_functions` is provided, aligning behavior with OpenAI's model. - Added new test cases to validate the execution of tools with available functions, ensuring correct argument passing and result formatting. This change improves the flexibility and usability of the Anthropic LLM integration, allowing for more complex interactions with tools. * refactor: remove redundant event emission in AnthropicCompletion * fix test * dry up	2026-02-03 16:30:43 -08:00
				`@@ -0,0 +1 @@`
				`"""Core crewAI components and interfaces."""`
				`@@ -0,0 +1 @@`
				`"""Provider interfaces for extensible crewAI components."""`