Add back AgentOps as Optional Dependency

pyproject.toml

@@ -26,9 +26,11 @@ click = "^8.1.7"
 python-dotenv = "^1.0.0"
 embedchain = "^0.1.98"
 appdirs = "^1.4.4"
+agentops = { version = "^0.1.9", optional = true }
 
 [tool.poetry.extras]
 tools = ["crewai-tools"]
+agentops = ["agentops"]
 
 [tool.poetry.group.dev.dependencies]
 isort = "^5.13.2"

src/crewai/agent.py

@@ -25,7 +25,20 @@
 from crewai.utilities import I18N, Logger, Prompts, RPMController
 from crewai.utilities.token_counter_callback import TokenCalcHandler, TokenProcess
 
+agentops = None
+try:
+    import agentops
+    from agentops import track_agent
+except ImportError:
 
+    def track_agent():
+        def noop(f):
+            return f
+
+        return noop
+
+
+@track_agent()
 class Agent(BaseModel):
     """Represents an agent in a system.
 
@@ -55,6 +68,8 @@ class Agent(BaseModel):
     _rpm_controller: RPMController = PrivateAttr(default=None)
     _request_within_rpm_limit: Any = PrivateAttr(default=None)
     _token_process: TokenProcess = TokenProcess()
+    agent_ops_agent_name: str = None
+    agent_ops_agent_id: str = None
 
     formatting_errors: int = 0
     model_config = ConfigDict(arbitrary_types_allowed=True)
@@ -138,6 +153,7 @@ class Agent(BaseModel):
     def __init__(__pydantic_self__, **data):
         config = data.pop("config", {})
         super().__init__(**config, **data)
+        __pydantic_self__.agent_ops_agent_name = __pydantic_self__.role
 
     @field_validator("id", mode="before")
     @classmethod
@@ -181,6 +197,12 @@ def set_agent_executor(self) -> "Agent":
             ):
                 self.llm.callbacks.append(token_handler)
 
+            if agentops and not any(
+                isinstance(handler, agentops.LangchainCallbackHandler) for handler in self.llm.callbacks
+            ):
+                agentops.stop_instrumenting()
+                self.llm.callbacks.append(agentops.LangchainCallbackHandler())
+
         if not self.agent_executor:
             if not self.cache_handler:
                 self.cache_handler = CacheHandler()

src/crewai/crew.py

@@ -27,6 +27,11 @@
 from crewai.tools.agent_tools import AgentTools
 from crewai.utilities import I18N, FileHandler, Logger, RPMController
 
+try:
+    import agentops
+except ImportError:
+    agentops = None
+
 
 class Crew(BaseModel):
     """
@@ -248,6 +253,9 @@ def kickoff(self, inputs: Optional[Dict[str, Any]] = {}) -> str:
         self._set_tasks_callbacks()
 
         i18n = I18N(prompt_file=self.prompt_file)
+        if agentops:
+            agentops.set_parent_key("daebe730-f54d-4af5-98df-e6946fb76d13")
+            agentops.add_tags(["crewai"])
 
         for agent in self.agents:
             agent.i18n = i18n
@@ -389,6 +397,10 @@ def _format_output(self, output: str) -> str:
     def _finish_execution(self, output) -> None:
         if self.max_rpm:
             self._rpm_controller.stop_rpm_counter()
+        if agentops:
+            agentops.end_session(
+                end_state="Success", end_state_reason="Finished Execution", is_auto_end=True
+            )
         self._telemetry.end_crew(self, output)
 
     def __repr__(self):

src/crewai/task.py

@@ -163,13 +163,16 @@ def execute(  # type: ignore # Missing return statement
             )
 
         if self.context:
-            context = []  # type: ignore # Incompatible types in assignment (expression has type "list[Never]", variable has type "str | None")
+            # type: ignore # Incompatible types in assignment (expression has type "list[Never]", variable has type "str | None")
+            context = []
             for task in self.context:
                 if task.async_execution:
                     task.thread.join()  # type: ignore # Item "None" of "Thread | None" has no attribute "join"
                 if task and task.output:
-                    context.append(task.output.raw_output)  # type: ignore # Item "str" of "str | None" has no attribute "append"
-            context = "\n".join(context)  # type: ignore # Argument 1 to "join" of "str" has incompatible type "str | None"; expected "Iterable[str]"
+                    # type: ignore # Item "str" of "str | None" has no attribute "append"
+                    context.append(task.output.raw_output)
+            # type: ignore # Argument 1 to "join" of "str" has incompatible type "str | None"; expected "Iterable[str]"
+            context = "\n".join(context)
 
         self.prompt_context = context
         tools = tools or self.tools
@@ -251,7 +254,8 @@ def _export_output(self, result: str) -> Any:
 
             # try to convert task_output directly to pydantic/json
             try:
-                exported_result = model.model_validate_json(result)  # type: ignore # Item "None" of "type[BaseModel] | None" has no attribute "model_validate_json"
+                # type: ignore # Item "None" of "type[BaseModel] | None" has no attribute "model_validate_json"
+                exported_result = model.model_validate_json(result)
                 if self.output_json:
                     return exported_result.model_dump()  # type: ignore # "str" has no attribute "model_dump"
                 return exported_result
@@ -260,17 +264,20 @@ def _export_output(self, result: str) -> Any:
                 match = re.search(r"({.*})", result, re.DOTALL)
                 if match:
                     try:
-                        exported_result = model.model_validate_json(match.group(0))  # type: ignore # Item "None" of "type[BaseModel] | None" has no attribute "model_validate_json"
+                        # type: ignore # Item "None" of "type[BaseModel] | None" has no attribute "model_validate_json"
+                        exported_result = model.model_validate_json(match.group(0))
                         if self.output_json:
                             return exported_result.model_dump()  # type: ignore # "str" has no attribute "model_dump"
                         return exported_result
                     except Exception:
                         pass
 
-            llm = self.agent.function_calling_llm or self.agent.llm  # type: ignore # Item "None" of "Agent | None" has no attribute "function_calling_llm"
+            # type: ignore # Item "None" of "Agent | None" has no attribute "function_calling_llm"
+            llm = self.agent.function_calling_llm or self.agent.llm
 
             if not self._is_gpt(llm):
-                model_schema = PydanticSchemaParser(model=model).get_schema()  # type: ignore # Argument "model" to "PydanticSchemaParser" has incompatible type "type[BaseModel] | None"; expected "type[BaseModel]"
+                # type: ignore # Argument "model" to "PydanticSchemaParser" has incompatible type "type[BaseModel] | None"; expected "type[BaseModel]"
+                model_schema = PydanticSchemaParser(model=model).get_schema()
                 instructions = f"{instructions}\n\nThe json should have the following structure, with the following keys:\n{model_schema}"
 
             converter = Converter(
@@ -301,12 +308,14 @@ def _is_gpt(self, llm) -> bool:
         return isinstance(llm, ChatOpenAI) and llm.openai_api_base is None
 
     def _save_file(self, result: Any) -> None:
-        directory = os.path.dirname(self.output_file)  # type: ignore # Value of type variable "AnyOrLiteralStr" of "dirname" cannot be "str | None"
+        # type: ignore # Value of type variable "AnyOrLiteralStr" of "dirname" cannot be "str | None"
+        directory = os.path.dirname(self.output_file)
 
         if directory and not os.path.exists(directory):
             os.makedirs(directory)
 
-        with open(self.output_file, "w", encoding="utf-8") as file:  # type: ignore # Argument 1 to "open" has incompatible type "str | None"; expected "int | str | bytes | PathLike[str] | PathLike[bytes]"
+        # type: ignore # Argument 1 to "open" has incompatible type "str | None"; expected "int | str | bytes | PathLike[str] | PathLike[bytes]"
+        with open(self.output_file, "w", encoding='utf-8') as file:
             file.write(result)
         return None
 

src/crewai/tools/tool_usage.py

@@ -11,6 +11,12 @@
 from crewai.tools.tool_calling import InstructorToolCalling, ToolCalling
 from crewai.utilities import I18N, Converter, ConverterError, Printer
 
+agentops = None
+try:
+    import agentops
+except ImportError:
+    pass
+
 OPENAI_BIGGER_MODELS = ["gpt-4"]
 
 
@@ -91,15 +97,18 @@ def use(
             self.task.increment_tools_errors()
             self._printer.print(content=f"\n\n{error}\n", color="red")
             return error
-        return f"{self._use(tool_string=tool_string, tool=tool, calling=calling)}"  # type: ignore # BUG?: "_use" of "ToolUsage" does not return a value (it only ever returns None)
+        # type: ignore # BUG?: "_use" of "ToolUsage" does not return a value (it only ever returns None)
+        return f"{self._use(tool_string=tool_string, tool=tool, calling=calling)}"
 
     def _use(
         self,
         tool_string: str,
         tool: BaseTool,
         calling: Union[ToolCalling, InstructorToolCalling],
     ) -> None:  # TODO: Fix this return type
-        if self._check_tool_repeated_usage(calling=calling):  # type: ignore # _check_tool_repeated_usage of "ToolUsage" does not return a value (it only ever returns None)
+        tool_event = agentops.ToolEvent(name=calling.tool_name) if agentops else None
+        # type: ignore # _check_tool_repeated_usage of "ToolUsage" does not return a value (it only ever returns None)
+        if self._check_tool_repeated_usage(calling=calling):
             try:
                 result = self._i18n.errors("task_repeated_usage").format(
                     tool_names=self.tools_names
@@ -110,13 +119,15 @@ def _use(
                     tool_name=tool.name,
                     attempts=self._run_attempts,
                 )
-                result = self._format_result(result=result)  # type: ignore #  "_format_result" of "ToolUsage" does not return a value (it only ever returns None)
+                # type: ignore #  "_format_result" of "ToolUsage" does not return a value (it only ever returns None)
+                result = self._format_result(result=result)
                 return result  # type: ignore # Fix the reutrn type of this function
 
             except Exception:
                 self.task.increment_tools_errors()
 
-        result = None  # type: ignore # Incompatible types in assignment (expression has type "None", variable has type "str")
+        # type: ignore # Incompatible types in assignment (expression has type "None", variable has type "str")
+        result = None
 
         if self.tools_handler.cache:
             result = self.tools_handler.cache.read(  # type: ignore # Incompatible types in assignment (expression has type "str | None", variable has type "str")
@@ -133,7 +144,8 @@ def _use(
 
                 if calling.arguments:
                     try:
-                        acceptable_args = tool.args_schema.schema()["properties"].keys()  # type: ignore # Item "None" of "type[BaseModel] | None" has no attribute "schema"
+                        # type: ignore # Item "None" of "type[BaseModel] | None" has no attribute "schema"
+                        acceptable_args = tool.args_schema.schema()["properties"].keys()
                         arguments = {
                             k: v
                             for k, v in calling.arguments.items()
@@ -145,7 +157,8 @@ def _use(
                             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]")
+                            # type: ignore # Incompatible types in assignment (expression has type "dict_values[str, Any]", variable has type "dict[str, Any]")
+                            arguments = calling.arguments.values()
                             result = tool._run(*arguments)
                 else:
                     result = tool._run()
@@ -164,6 +177,10 @@ def _use(
                     return error  # type: ignore # No return value expected
 
                 self.task.increment_tools_errors()
+                if agentops:
+                    agentops.record(
+                        agentops.ErrorEvent(exception=e, trigger_event=tool_event)
+                    )
                 return self.use(calling=calling, tool_string=tool_string)  # type: ignore # No return value expected
 
             if self.tools_handler:
@@ -184,18 +201,22 @@ def _use(
                 )
 
         self._printer.print(content=f"\n\n{result}\n", color="purple")
+        if agentops:
+            agentops.record(tool_event)
         self._telemetry.tool_usage(
             llm=self.function_calling_llm,
             tool_name=tool.name,
             attempts=self._run_attempts,
         )
-        result = self._format_result(result=result)  # type: ignore # "_format_result" of "ToolUsage" does not return a value (it only ever returns None)
+        # type: ignore # "_format_result" of "ToolUsage" does not return a value (it only ever returns None)
+        result = self._format_result(result=result)
         return result  # type: ignore # No return value expected
 
     def _format_result(self, result: Any) -> None:
         self.task.used_tools += 1
         if self._should_remember_format():  # type: ignore # "_should_remember_format" of "ToolUsage" does not return a value (it only ever returns None)
-            result = self._remember_format(result=result)  # type: ignore # "_remember_format" of "ToolUsage" does not return a value (it only ever returns None)
+            # type: ignore # "_remember_format" of "ToolUsage" does not return a value (it only ever returns None)
+            result = self._remember_format(result=result)
         return result
 
     def _should_remember_format(self) -> None:

src/crewai/utilities/evaluators/task_evaluator.py

@@ -5,6 +5,17 @@
 
 from crewai.utilities import Converter
 from crewai.utilities.pydantic_schema_parser import PydanticSchemaParser
+agentops = None
+try:
+    import agentops
+    from agentops import track_agent
+except ImportError:
+
+    def track_agent(name):
+        def noop(f):
+            return f
+
+        return noop
 
 
 class Entity(BaseModel):
@@ -26,6 +37,7 @@ class TaskEvaluation(BaseModel):
     )
 
 
+@track_agent(name="Task Evaluator")
 class TaskEvaluator:
     def __init__(self, original_agent):
         self.llm = original_agent.llm

src/crewai/utilities/logger.py

@@ -1,5 +1,5 @@
 from crewai.utilities.printer import Printer
-
+from datetime import datetime
 
 class Logger:
     _printer = Printer()