Merge branch 'bugfix/langchain-tool-config-change' into feature/procedure_v2

src/crewai/agent.py

@@ -181,7 +181,6 @@ class Agent(BaseAgent):
         self.agent_executor.tools = parsed_tools
         self.agent_executor.task = task
 
-        # TODO: COMPARE WITH ARGS AND WITHOUT ARGS
         self.agent_executor.tools_description = self._render_text_description_and_args(
             parsed_tools
         )
@@ -200,11 +199,13 @@ class Agent(BaseAgent):
                     "tools": self.agent_executor.tools_description,
                 }
             )["output"]
+            print("Result when things went well:", result)
         except Exception as e:
+            print("FAILED TO EXECUTE TASK", e)
             self._times_executed += 1
             if self._times_executed > self.max_retry_limit:
                 raise e
-            self.execute_task(task, context, tools)
+            return self.execute_task(task, context, tools)
 
         if self.max_rpm:
             self._rpm_controller.stop_rpm_counter()
@@ -216,6 +217,7 @@ class Agent(BaseAgent):
             if tool_result.get("result_as_answer", False):
                 result = tool_result["result"]
 
+        print("RESULT TO RETURN", result)
         return result
 
     def format_log_to_str(

src/crewai/agents/executor.py

@@ -56,7 +56,7 @@ class CrewAgentExecutor(AgentExecutor, CrewAgentExecutorMixin):
         )
         intermediate_steps: List[Tuple[AgentAction, str]] = []
         # Allowing human input given task setting
-        if self.task.human_input:
+        if self.task and self.task.human_input:
             self.should_ask_for_human_input = True
 
         # Let's start tracking the number of iterations and time elapsed

src/crewai/crews/crew_output.py

@@ -24,18 +24,6 @@ class CrewOutput(BaseModel):
         description="Processed token summary", default={}
     )
 
-    # TODO: Joao - Adding this safety check breakes when people want to see
-    #                   The full output of a CrewOutput.
-    # @property
-    # def pydantic(self) -> Optional[BaseModel]:
-    #     # Check if the final task output included a pydantic model
-    #     if self.tasks_output[-1].output_format != OutputFormat.PYDANTIC:
-    #         raise ValueError(
-    #             "No pydantic model found in the final task. Please make sure to set the output_pydantic property in the final task in your crew."
-    #         )
-
-    #     return self._pydantic
-
     @property
     def json(self) -> Optional[str]:
         if self.tasks_output[-1].output_format != OutputFormat.JSON:
@@ -46,6 +34,9 @@ class CrewOutput(BaseModel):
         return json.dumps(self.json_dict)
 
     def to_dict(self) -> Dict[str, Any]:
+        print("Crew Output RAW", self.raw)
+        print("Crew Output JSON", self.json_dict)
+        print("Crew Output Pydantic", self.pydantic)
         if self.json_dict:
             return self.json_dict
         if self.pydantic:

src/crewai/procedure/procedure.py

@@ -12,21 +12,46 @@ class Procedure(BaseModel):
         ..., description="List of crews to be executed in sequence"
     )
 
-    async def kickoff(self, inputs: List[Dict[str, Any]]) -> List[CrewOutput]:
+    def kickoff(self, inputs: List[Dict[str, Any]]) -> List[CrewOutput]:
         current_inputs = inputs
 
-        for crew in self.crews:
+        for index, crew in enumerate(self.crews):
             # Process all inputs for the current crew
-            crew_outputs = await self._process_crew(crew, current_inputs)
-            print("Crew Outputs", crew_outputs)
+            crew_outputs = self._process_crew(crew, current_inputs)
 
-            # Prepare inputs for the next crew
-            current_inputs = [output.to_dict() for output in crew_outputs]
+            # If this is not the last crew, prepare inputs for the next crew
+            if index < len(self.crews) - 1:
+                current_inputs = [output.to_dict() for output in crew_outputs]
+            else:
+                # For the last crew, we don't need to convert the output to input
+                return crew_outputs
 
-        # Return the final outputs
         return crew_outputs
 
-    async def _process_crew(
+    async def kickoff_async(self, inputs: List[Dict[str, Any]]) -> List[CrewOutput]:
+        current_inputs = inputs
+        for index, crew in enumerate(self.crews):
+            # Process all inputs for the current crew
+            crew_outputs = await self._process_crew(crew, current_inputs)
+
+            # If this is not the last crew, prepare inputs for the next crew
+            if index < len(self.crews) - 1:
+                current_inputs = [output.to_dict() for output in crew_outputs]
+            else:
+                # For the last crew, we don't need to convert the output to input
+                return crew_outputs
+
+        return crew_outputs
+
+    def _process_crew(
+        self, crew: Crew, inputs: List[Dict[str, Any]]
+    ) -> List[CrewOutput]:
+        # Kickoff crew for each input
+        outputs = [crew.kickoff(inputs=input_data) for input_data in inputs]
+
+        return outputs
+
+    async def _process_crew_async(
         self, crew: Crew, inputs: List[Dict[str, Any]]
     ) -> List[CrewOutput]:
         # Kickoff crew asynchronously for each input

src/crewai/tools/tool_usage.py

@@ -151,16 +151,12 @@ class ToolUsage:
                             for k, v in calling.arguments.items()
                             if k in acceptable_args
                         }
-                        result = tool._run(**arguments)
+                        result = tool.invoke(input=arguments)
                     except Exception:
-                        if tool.args_schema:
-                            arguments = calling.arguments
-                            result = tool._run(**arguments)
-                        else:
-                            arguments = calling.arguments.values()  # type: ignore # Incompatible types in assignment (expression has type "dict_values[str, Any]", variable has type "dict[str, Any]")
-                            result = tool._run(*arguments)
+                        arguments = calling.arguments
+                        result = tool.invoke(input=arguments)
                 else:
-                    result = tool._run()
+                    result = tool.invoke(input={})
             except Exception as e:
                 self._run_attempts += 1
                 if self._run_attempts > self._max_parsing_attempts: