Merge branch 'main' into devin/1735591359-circular-import-fix

src/crewai/tools/agent_tools/base_agent_tools.py

@@ -1,3 +1,4 @@
+import logging
 from typing import Optional, Union
 
 from pydantic import Field
@@ -7,6 +8,8 @@ from crewai.task import Task
 from crewai.tools.base_tool import BaseTool
 from crewai.utilities import I18N
 
+logger = logging.getLogger(__name__)
+
 
 class BaseAgentTool(BaseTool):
     """Base class for agent-related tools"""
@@ -16,6 +19,25 @@ class BaseAgentTool(BaseTool):
         default_factory=I18N, description="Internationalization settings"
     )
 
+    def sanitize_agent_name(self, name: str) -> str:
+        """
+        Sanitize agent role name by normalizing whitespace and setting to lowercase.
+        Converts all whitespace (including newlines) to single spaces and removes quotes.
+
+        Args:
+            name (str): The agent role name to sanitize
+
+        Returns:
+            str: The sanitized agent role name, with whitespace normalized,
+                 converted to lowercase, and quotes removed
+        """
+        if not name:
+            return ""
+        # Normalize all whitespace (including newlines) to single spaces
+        normalized = " ".join(name.split())
+        # Remove quotes and convert to lowercase
+        return normalized.replace('"', "").casefold()
+
     def _get_coworker(self, coworker: Optional[str], **kwargs) -> Optional[str]:
         coworker = coworker or kwargs.get("co_worker") or kwargs.get("coworker")
         if coworker:
@@ -25,11 +47,27 @@ class BaseAgentTool(BaseTool):
         return coworker
 
     def _execute(
-        self, agent_name: Union[str, None], task: str, context: Union[str, None]
+        self,
+        agent_name: Optional[str],
+        task: str,
+        context: Optional[str] = None
     ) -> str:
+        """
+        Execute delegation to an agent with case-insensitive and whitespace-tolerant matching.
+        
+        Args:
+            agent_name: Name/role of the agent to delegate to (case-insensitive)
+            task: The specific question or task to delegate
+            context: Optional additional context for the task execution
+            
+        Returns:
+            str: The execution result from the delegated agent or an error message
+                 if the agent cannot be found
+        """
         try:
             if agent_name is None:
                 agent_name = ""
+                logger.debug("No agent name provided, using empty string")
 
             # It is important to remove the quotes from the agent name.
             # The reason we have to do this is because less-powerful LLM's
@@ -38,31 +76,49 @@ class BaseAgentTool(BaseTool):
             # {"task": "....", "coworker": "....
             # when it should look like this:
             # {"task": "....", "coworker": "...."}
-            agent_name = agent_name.casefold().replace('"', "").replace("\n", "")
+            sanitized_name = self.sanitize_agent_name(agent_name)
+            logger.debug(f"Sanitized agent name from '{agent_name}' to '{sanitized_name}'")
+
+            available_agents = [agent.role for agent in self.agents]
+            logger.debug(f"Available agents: {available_agents}")
+
             agent = [  # type: ignore # Incompatible types in assignment (expression has type "list[BaseAgent]", variable has type "str | None")
                 available_agent
                 for available_agent in self.agents
-                if available_agent.role.casefold().replace("\n", "") == agent_name
+                if self.sanitize_agent_name(available_agent.role) == sanitized_name
             ]
-        except Exception as _:
+            logger.debug(f"Found {len(agent)} matching agents for role '{sanitized_name}'")
+        except (AttributeError, ValueError) as e:
+            # Handle specific exceptions that might occur during role name processing
             return self.i18n.errors("agent_tool_unexisting_coworker").format(
                 coworkers="\n".join(
-                    [f"- {agent.role.casefold()}" for agent in self.agents]
-                )
+                    [f"- {self.sanitize_agent_name(agent.role)}" for agent in self.agents]
+                ),
+                error=str(e)
             )
 
         if not agent:
+            # No matching agent found after sanitization
             return self.i18n.errors("agent_tool_unexisting_coworker").format(
                 coworkers="\n".join(
-                    [f"- {agent.role.casefold()}" for agent in self.agents]
-                )
+                    [f"- {self.sanitize_agent_name(agent.role)}" for agent in self.agents]
+                ),
+                error=f"No agent found with role '{sanitized_name}'"
             )
 
         agent = agent[0]
-        task_with_assigned_agent = Task(  # type: ignore # Incompatible types in assignment (expression has type "Task", variable has type "str")
-            description=task,
-            agent=agent,
-            expected_output=agent.i18n.slice("manager_request"),
-            i18n=agent.i18n,
-        )
-        return agent.execute_task(task_with_assigned_agent, context)
+        try:
+            task_with_assigned_agent = Task(
+                description=task,
+                agent=agent,
+                expected_output=agent.i18n.slice("manager_request"),
+                i18n=agent.i18n,
+            )
+            logger.debug(f"Created task for agent '{self.sanitize_agent_name(agent.role)}': {task}")
+            return agent.execute_task(task_with_assigned_agent, context)
+        except Exception as e:
+            # Handle task creation or execution errors
+            return self.i18n.errors("agent_tool_execution_error").format(
+                agent_role=self.sanitize_agent_name(agent.role),
+                error=str(e)
+            )

src/crewai/translations/en.json

@@ -33,7 +33,8 @@
     "tool_usage_error": "I encountered an error: {error}",
     "tool_arguments_error": "Error: the Action Input is not a valid key, value dictionary.",
     "wrong_tool_name": "You tried to use the tool {tool}, but it doesn't exist. You must use one of the following tools, use one at time: {tools}.",
-    "tool_usage_exception": "I encountered an error while trying to use the tool. This was the error: {error}.\n Tool {tool} accepts these inputs: {tool_inputs}"
+    "tool_usage_exception": "I encountered an error while trying to use the tool. This was the error: {error}.\n Tool {tool} accepts these inputs: {tool_inputs}",
+    "agent_tool_execution_error": "Error executing task with agent '{agent_role}'. Error: {error}"
   },
   "tools": {
     "delegate_work": "Delegate a specific task to one of the following coworkers: {coworkers}\nThe input to this tool should be the coworker, the task you want them to do, and ALL necessary context to execute the task, they know nothing about the task, so share absolute everything you know, don't reference things but instead explain them.",