Lorenzejay/byoa (#776)

* better spacing

* works with llama index

* works on langchain custom just need delegation to work

* cleanup for custom_agent class

* works with different argument expectations for agent_executor

* cleanup for hierarchial process, better agent_executor args handler and added to the crew agent doc page

* removed code examples for langchain + llama index, added to docs instead

* added key output if return is not a str for and added some tests

* added hinting for CustomAgent class

* removed pass as it was not needed

* closer just need to figuire ou agentTools

* running agents - llamaindex and langchain with base agent

* some cleanup on baseAgent

* minimum for agent to run for base class and ensure it works with hierarchical process

* cleanup for original agent to take on BaseAgent class

* Agent takes on langchainagent and cleanup across

* token handling working for usage_metrics to continue working

* installed llama-index, updated docs and added better name

* fixed some type errors

* base agent holds token_process

* heirarchail process uses proper tools and no longer relies on hasattr for token_processes

* removal of test_custom_agent_executions

* this fixes copying agents

* leveraging an executor class for trigger llamaindex agent

* llama index now has ask_human

* executor mixins added

* added output converter base class

* type listed

* cleanup for output conversions and tokenprocess eliminated redundancy

* properly handling tokens

* simplified token calc handling

* original agent with base agent builder structure setup

* better docs

* no more llama-index dep

* cleaner docs

* test fixes

* poetry reverts and better docs

* base_agent_tools set for third party agents

* updated task and test fix

src/crewai/__init__.py

@@ -2,3 +2,5 @@ from crewai.agent import Agent
 from crewai.crew import Crew
 from crewai.process import Process
 from crewai.task import Task
+
+__all__ = ["Agent", "Crew", "Process", "Task"]

src/crewai/agent.py

@@ -1,7 +1,5 @@
 import os
-import uuid
-from copy import deepcopy
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, List, Optional, Tuple
 
 from langchain.agents.agent import RunnableAgent
 from langchain.agents.tools import tool as LangChainTool
@@ -9,27 +7,20 @@ from langchain.tools.render import render_text_description
 from langchain_core.agents import AgentAction
 from langchain_core.callbacks import BaseCallbackHandler
 from langchain_openai import ChatOpenAI
-from pydantic import (
-    UUID4,
-    BaseModel,
-    ConfigDict,
-    Field,
-    InstanceOf,
-    PrivateAttr,
-    field_validator,
-    model_validator,
-)
-from pydantic_core import PydanticCustomError
 
-from crewai.agents import CacheHandler, CrewAgentExecutor, CrewAgentParser, ToolsHandler
+from pydantic import Field, InstanceOf, model_validator
+
+from crewai.agents import CacheHandler, CrewAgentExecutor, CrewAgentParser
 from crewai.memory.contextual.contextual_memory import ContextualMemory
-from crewai.utilities import I18N, Logger, Prompts, RPMController
+from crewai.tools.agent_tools import AgentTools
+from crewai.utilities import Prompts, Converter
 from crewai.utilities.constants import TRAINED_AGENTS_DATA_FILE, TRAINING_DATA_FILE
-from crewai.utilities.token_counter_callback import TokenCalcHandler, TokenProcess
+from crewai.utilities.token_counter_callback import TokenCalcHandler
+from crewai.agents.agent_builder.base_agent import BaseAgent
 from crewai.utilities.training_handler import CrewTrainingHandler
 
 
-class Agent(BaseModel):
+class Agent(BaseAgent):
     """Represents an agent in a system.
 
     Each agent has a role, a goal, a backstory, and an optional language model (llm).
@@ -53,57 +44,10 @@ class Agent(BaseModel):
             callbacks: A list of callback functions from the langchain library that are triggered during the agent's execution process
     """
 
-    __hash__ = object.__hash__  # type: ignore
-    _logger: Logger = PrivateAttr()
-    _rpm_controller: RPMController = PrivateAttr(default=None)
-    _request_within_rpm_limit: Any = PrivateAttr(default=None)
-    _token_process: TokenProcess = TokenProcess()
-
-    formatting_errors: int = 0
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-    id: UUID4 = Field(
-        default_factory=uuid.uuid4,
-        frozen=True,
-        description="Unique identifier for the object, not set by user.",
-    )
-    role: str = Field(description="Role of the agent")
-    goal: str = Field(description="Objective of the agent")
-    backstory: str = Field(description="Backstory of the agent")
-    cache: bool = Field(
-        default=True,
-        description="Whether the agent should use a cache for tool usage.",
-    )
-    config: Optional[Dict[str, Any]] = Field(
-        description="Configuration for the agent",
-        default=None,
-    )
-    max_rpm: Optional[int] = Field(
-        default=None,
-        description="Maximum number of requests per minute for the agent execution to be respected.",
-    )
-    verbose: bool = Field(
-        default=False, description="Verbose mode for the Agent Execution"
-    )
-    allow_delegation: bool = Field(
-        default=True, description="Allow delegation of tasks to agents"
-    )
-    tools: Optional[List[Any]] = Field(
-        default_factory=list, description="Tools at agents disposal"
-    )
-    max_iter: Optional[int] = Field(
-        default=25, description="Maximum iterations for an agent to execute a task"
-    )
     max_execution_time: Optional[int] = Field(
         default=None,
         description="Maximum execution time for an agent to execute a task",
     )
-    agent_executor: InstanceOf[CrewAgentExecutor] = Field(
-        default=None, description="An instance of the CrewAgentExecutor class."
-    )
-    crew: Any = Field(default=None, description="Crew to which the agent belongs.")
-    tools_handler: InstanceOf[ToolsHandler] = Field(
-        default=None, description="An instance of the ToolsHandler class."
-    )
     cache_handler: InstanceOf[CacheHandler] = Field(
         default=None, description="An instance of the CacheHandler class."
     )
@@ -111,7 +55,6 @@ class Agent(BaseModel):
         default=None,
         description="Callback to be executed after each step of the agent execution.",
     )
-    i18n: I18N = Field(default=I18N(), description="Internationalization settings.")
     llm: Any = Field(
         default_factory=lambda: ChatOpenAI(
             model=os.environ.get("OPENAI_MODEL_NAME", "gpt-4o")
@@ -133,47 +76,18 @@ class Agent(BaseModel):
     response_template: Optional[str] = Field(
         default=None, description="Response format for the agent."
     )
+
     allow_code_execution: Optional[bool] = Field(
         default=False, description="Enable code execution for the agent."
     )
 
-    _original_role: str | None = None
-    _original_goal: str | None = None
-    _original_backstory: str | None = None
-
     def __init__(__pydantic_self__, **data):
         config = data.pop("config", {})
         super().__init__(**config, **data)
 
-    @field_validator("id", mode="before")
-    @classmethod
-    def _deny_user_set_id(cls, v: Optional[UUID4]) -> None:
-        if v:
-            raise PydanticCustomError(
-                "may_not_set_field", "This field is not to be set by the user.", {}
-            )
-
-    @model_validator(mode="after")
-    def set_attributes_based_on_config(self) -> "Agent":
-        """Set attributes based on the agent configuration."""
-        if self.config:
-            for key, value in self.config.items():
-                setattr(self, key, value)
-        return self
-
-    @model_validator(mode="after")
-    def set_private_attrs(self):
-        """Set private attributes."""
-        self._logger = Logger(self.verbose)
-        if self.max_rpm and not self._rpm_controller:
-            self._rpm_controller = RPMController(
-                max_rpm=self.max_rpm, logger=self._logger
-            )
-        return self
-
     @model_validator(mode="after")
     def set_agent_executor(self) -> "Agent":
-        """set agent executor is set."""
+        """Ensure agent executor and token process is set."""
         if hasattr(self.llm, "model_name"):
             token_handler = TokenCalcHandler(self.llm.model_name, self._token_process)
 
@@ -232,8 +146,7 @@ class Agent(BaseModel):
 
         tools = tools or self.tools
         # type: ignore # Argument 1 to "_parse_tools" of "Agent" has incompatible type "list[Any] | None"; expected "list[Any]"
-        parsed_tools = self._parse_tools(tools)
-
+        parsed_tools = self._parse_tools(tools or [])
         self.create_agent_executor(tools=tools)
         self.agent_executor.tools = parsed_tools
         self.agent_executor.task = task
@@ -253,33 +166,22 @@ class Agent(BaseModel):
                 "tools": self.agent_executor.tools_description,
             }
         )["output"]
-
         if self.max_rpm:
             self._rpm_controller.stop_rpm_counter()
-
         return result
 
-    def set_cache_handler(self, cache_handler: CacheHandler) -> None:
-        """Set the cache handler for the agent.
-
-        Args:
-            cache_handler: An instance of the CacheHandler class.
-        """
-        self.tools_handler = ToolsHandler()
-        if self.cache:
-            self.cache_handler = cache_handler
-            self.tools_handler.cache = cache_handler
-        self.create_agent_executor()
-
-    def set_rpm_controller(self, rpm_controller: RPMController) -> None:
-        """Set the rpm controller for the agent.
-
-        Args:
-            rpm_controller: An instance of the RPMController class.
-        """
-        if not self._rpm_controller:
-            self._rpm_controller = rpm_controller
-            self.create_agent_executor()
+    def format_log_to_str(
+        self,
+        intermediate_steps: List[Tuple[AgentAction, str]],
+        observation_prefix: str = "Observation: ",
+        llm_prefix: str = "",
+    ) -> str:
+        """Construct the scratchpad that lets the agent continue its thought process."""
+        thoughts = ""
+        for action, observation in intermediate_steps:
+            thoughts += action.log
+            thoughts += f"\n{observation_prefix}{observation}\n{llm_prefix}"
+        return thoughts
 
     def create_agent_executor(self, tools=None) -> None:
         """Create an agent executor for the agent.
@@ -335,76 +237,32 @@ class Agent(BaseModel):
         )
 
         stop_words = [self.i18n.slice("observation")]
+
         if self.response_template:
             stop_words.append(
                 self.response_template.split("{{ .Response }}")[1].strip()
             )
 
         bind = self.llm.bind(stop=stop_words)
+
         inner_agent = agent_args | execution_prompt | bind | CrewAgentParser(agent=self)
         self.agent_executor = CrewAgentExecutor(
             agent=RunnableAgent(runnable=inner_agent), **executor_args
         )
 
-    def interpolate_inputs(self, inputs: Dict[str, Any]) -> None:
-        """Interpolate inputs into the agent description and backstory."""
-        if self._original_role is None:
-            self._original_role = self.role
-        if self._original_goal is None:
-            self._original_goal = self.goal
-        if self._original_backstory is None:
-            self._original_backstory = self.backstory
+    def get_delegation_tools(self, agents: List[BaseAgent]):
+        agent_tools = AgentTools(agents=agents)
+        tools = agent_tools.tools()
+        return tools
 
-        if inputs:
-            self.role = self._original_role.format(**inputs)
-            self.goal = self._original_goal.format(**inputs)
-            self.backstory = self._original_backstory.format(**inputs)
+    def get_output_converter(self, llm, text, model, instructions):
+        return Converter(llm=llm, text=text, model=model, instructions=instructions)
 
-    def increment_formatting_errors(self) -> None:
-        """Count the formatting errors of the agent."""
-        self.formatting_errors += 1
-
-    def format_log_to_str(
-        self,
-        intermediate_steps: List[Tuple[AgentAction, str]],
-        observation_prefix: str = "Observation: ",
-        llm_prefix: str = "",
-    ) -> str:
-        """Construct the scratchpad that lets the agent continue its thought process."""
-        thoughts = ""
-        for action, observation in intermediate_steps:
-            thoughts += action.log
-            thoughts += f"\n{observation_prefix}{observation}\n{llm_prefix}"
-        return thoughts
-
-    def copy(self):
-        """Create a deep copy of the Agent."""
-        exclude = {
-            "id",
-            "_logger",
-            "_rpm_controller",
-            "_request_within_rpm_limit",
-            "_token_process",
-            "agent_executor",
-            "tools",
-            "tools_handler",
-            "cache_handler",
-        }
-
-        copied_data = self.model_dump(exclude=exclude)
-        copied_data = {k: v for k, v in copied_data.items() if v is not None}
-
-        copied_agent = Agent(**copied_data)
-        copied_agent.tools = deepcopy(self.tools)
-
-        return copied_agent
-
-    # type: ignore # Function "langchain_core.tools.tool" is not valid as a type
     def _parse_tools(self, tools: List[Any]) -> List[LangChainTool]:
         """Parse tools to be used for the task."""
-        # tentatively try to import from crewai_tools import BaseTool as CrewAITool
         tools_list = []
         try:
+            # tentatively try to import from crewai_tools import BaseTool as CrewAITool
             from crewai_tools import BaseTool as CrewAITool
 
             for tool in tools:

src/crewai/agents/agent_builder/base_agent.py

@@ -0,0 +1,256 @@
+from copy import deepcopy
+import uuid
+from typing import Any, Dict, List, Optional
+from abc import ABC, abstractmethod
+from pydantic import (
+    UUID4,
+    BaseModel,
+    Field,
+    InstanceOf,
+    field_validator,
+    model_validator,
+    ConfigDict,
+    PrivateAttr,
+)
+from pydantic_core import PydanticCustomError
+
+from crewai.utilities import I18N, RPMController, Logger
+from crewai.agents import CacheHandler, ToolsHandler
+from crewai.utilities.token_counter_callback import TokenProcess
+
+
+class BaseAgent(ABC, BaseModel):
+    """Abstract Base Class for all third party agents compatible with CrewAI.
+
+    Attributes:
+        id (UUID4): Unique identifier for the agent.
+        role (str): Role of the agent.
+        goal (str): Objective of the agent.
+        backstory (str): Backstory of the agent.
+        cache (bool): Whether the agent should use a cache for tool usage.
+        config (Optional[Dict[str, Any]]): Configuration for the agent.
+        verbose (bool): Verbose mode for the Agent Execution.
+        max_rpm (Optional[int]): Maximum number of requests per minute for the agent execution.
+        allow_delegation (bool): Allow delegation of tasks to agents.
+        tools (Optional[List[Any]]): Tools at the agent's disposal.
+        max_iter (Optional[int]): Maximum iterations for an agent to execute a task.
+        agent_executor (InstanceOf): An instance of the CrewAgentExecutor class.
+        llm (Any): Language model that will run the agent.
+        crew (Any): Crew to which the agent belongs.
+        i18n (I18N): Internationalization settings.
+        cache_handler (InstanceOf[CacheHandler]): An instance of the CacheHandler class.
+        tools_handler (InstanceOf[ToolsHandler]): An instance of the ToolsHandler class.
+
+
+    Methods:
+        execute_task(task: Any, context: Optional[str] = None, tools: Optional[List[Any]] = None) -> str:
+            Abstract method to execute a task.
+        create_agent_executor(tools=None) -> None:
+            Abstract method to create an agent executor.
+        _parse_tools(tools: List[Any]) -> List[Any]:
+            Abstract method to parse tools.
+        get_delegation_tools(agents: List["BaseAgent"]):
+            Abstract method to set the agents task tools for handling delegation and question asking to other agents in crew.
+        get_output_converter(llm, model, instructions):
+            Abstract method to get the converter class for the agent to create json/pydantic outputs.
+        interpolate_inputs(inputs: Dict[str, Any]) -> None:
+            Interpolate inputs into the agent description and backstory.
+        set_cache_handler(cache_handler: CacheHandler) -> None:
+            Set the cache handler for the agent.
+        increment_formatting_errors() -> None:
+            Increment formatting errors.
+        copy() -> "BaseAgent":
+            Create a copy of the agent.
+        set_rpm_controller(rpm_controller: RPMController) -> None:
+            Set the rpm controller for the agent.
+        set_private_attrs() -> "BaseAgent":
+            Set private attributes.
+    """
+
+    __hash__ = object.__hash__  # type: ignore
+    _logger: Logger = PrivateAttr()
+    _rpm_controller: RPMController = PrivateAttr(default=None)
+    _request_within_rpm_limit: Any = PrivateAttr(default=None)
+    formatting_errors: int = 0
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+    id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
+    role: str = Field(description="Role of the agent")
+    goal: str = Field(description="Objective of the agent")
+    backstory: str = Field(description="Backstory of the agent")
+    cache: bool = Field(
+        default=True, description="Whether the agent should use a cache for tool usage."
+    )
+    config: Optional[Dict[str, Any]] = Field(
+        description="Configuration for the agent", default=None
+    )
+    verbose: bool = Field(
+        default=False, description="Verbose mode for the Agent Execution"
+    )
+    max_rpm: Optional[int] = Field(
+        default=None,
+        description="Maximum number of requests per minute for the agent execution to be respected.",
+    )
+    allow_delegation: bool = Field(
+        default=True, description="Allow delegation of tasks to agents"
+    )
+    tools: Optional[List[Any]] = Field(
+        default_factory=list, description="Tools at agents' disposal"
+    )
+    max_iter: Optional[int] = Field(
+        default=25, description="Maximum iterations for an agent to execute a task"
+    )
+    agent_executor: InstanceOf = Field(
+        default=None, description="An instance of the CrewAgentExecutor class."
+    )
+    llm: Any = Field(
+        default=None, description="Language model that will run the agent."
+    )
+    crew: Any = Field(default=None, description="Crew to which the agent belongs.")
+    i18n: I18N = Field(default=I18N(), description="Internationalization settings.")
+    cache_handler: InstanceOf[CacheHandler] = Field(
+        default=None, description="An instance of the CacheHandler class."
+    )
+    tools_handler: InstanceOf[ToolsHandler] = Field(
+        default=None, description="An instance of the ToolsHandler class."
+    )
+
+    _original_role: str | None = None
+    _original_goal: str | None = None
+    _original_backstory: str | None = None
+    _token_process: TokenProcess = TokenProcess()
+
+    def __init__(__pydantic_self__, **data):
+        config = data.pop("config", {})
+        super().__init__(**config, **data)
+
+    @model_validator(mode="after")
+    def set_config_attributes(self):
+        if self.config:
+            for key, value in self.config.items():
+                setattr(self, key, value)
+        return self
+
+    @field_validator("id", mode="before")
+    @classmethod
+    def _deny_user_set_id(cls, v: Optional[UUID4]) -> None:
+        if v:
+            raise PydanticCustomError(
+                "may_not_set_field", "This field is not to be set by the user.", {}
+            )
+
+    @model_validator(mode="after")
+    def set_attributes_based_on_config(self) -> "BaseAgent":
+        """Set attributes based on the agent configuration."""
+        if self.config:
+            for key, value in self.config.items():
+                setattr(self, key, value)
+        return self
+
+    @model_validator(mode="after")
+    def set_private_attrs(self):
+        """Set private attributes."""
+        self._logger = Logger(self.verbose)
+        if self.max_rpm and not self._rpm_controller:
+            self._rpm_controller = RPMController(
+                max_rpm=self.max_rpm, logger=self._logger
+            )
+        if not self._token_process:
+            self._token_process = TokenProcess()
+        return self
+
+    @abstractmethod
+    def execute_task(
+        self,
+        task: Any,
+        context: Optional[str] = None,
+        tools: Optional[List[Any]] = None,
+    ) -> str:
+        pass
+
+    @abstractmethod
+    def create_agent_executor(self, tools=None) -> None:
+        pass
+
+    @abstractmethod
+    def _parse_tools(self, tools: List[Any]) -> List[Any]:
+        pass
+
+    @abstractmethod
+    def get_delegation_tools(self, agents: List["BaseAgent"]):
+        """Set the task tools that init BaseAgenTools class."""
+        pass
+
+    @abstractmethod
+    def get_output_converter(
+        self, llm: Any, text: str, model: type[BaseModel] | None, instructions: str
+    ):
+        """Get the converter class for the agent to create json/pydantic outputs."""
+        pass
+
+    def interpolate_inputs(self, inputs: Dict[str, Any]) -> None:
+        """Interpolate inputs into the agent description and backstory."""
+        if self._original_role is None:
+            self._original_role = self.role
+        if self._original_goal is None:
+            self._original_goal = self.goal
+        if self._original_backstory is None:
+            self._original_backstory = self.backstory
+
+        if inputs:
+            self.role = self._original_role.format(**inputs)
+            self.goal = self._original_goal.format(**inputs)
+            self.backstory = self._original_backstory.format(**inputs)
+
+    def set_cache_handler(self, cache_handler: CacheHandler) -> None:
+        """Set the cache handler for the agent.
+
+        Args:
+            cache_handler: An instance of the CacheHandler class.
+        """
+        self.tools_handler = ToolsHandler()
+        if self.cache:
+            self.cache_handler = cache_handler
+            self.tools_handler.cache = cache_handler
+        self.create_agent_executor()
+
+    def increment_formatting_errors(self) -> None:
+        print("Formatting errors incremented")
+
+    def copy(self):
+        exclude = {
+            "id",
+            "_logger",
+            "_rpm_controller",
+            "_request_within_rpm_limit",
+            "token_process",
+            "agent_executor",
+            "tools",
+            "tools_handler",
+            "cache_handler",
+            "crew",
+            "llm",
+        }
+
+        copied_data = self.model_dump(exclude=exclude, exclude_unset=True)
+        copied_agent = self.__class__(**copied_data)
+
+        # Copy mutable attributes separately
+        copied_agent.tools = deepcopy(self.tools)
+        copied_agent.config = deepcopy(self.config)
+
+        # Preserve original values for interpolation
+        copied_agent._original_role = self._original_role
+        copied_agent._original_goal = self._original_goal
+        copied_agent._original_backstory = self._original_backstory
+
+        return copied_agent
+
+    def set_rpm_controller(self, rpm_controller: RPMController) -> None:
+        """Set the rpm controller for the agent.
+
+        Args:
+            rpm_controller: An instance of the RPMController class.
+        """
+        if not self._rpm_controller:
+            self._rpm_controller = rpm_controller
+            self.create_agent_executor()

src/crewai/agents/agent_builder/base_agent_executor_mixin.py

@@ -0,0 +1,65 @@
+import time
+
+from crewai.memory.entity.entity_memory_item import EntityMemoryItem
+from crewai.memory.long_term.long_term_memory_item import LongTermMemoryItem
+from crewai.memory.short_term.short_term_memory_item import ShortTermMemoryItem
+from crewai.utilities.converter import ConverterError
+from crewai.utilities.evaluators.task_evaluator import TaskEvaluator
+
+
+class CrewAgentExecutorMixin:
+    def _should_force_answer(self) -> bool:
+        return (
+            self.iterations == self.force_answer_max_iterations
+        ) and not self.have_forced_answer
+
+    def _create_short_term_memory(self, output) -> None:
+        if (
+            self.crew
+            and self.crew.memory
+            and "Action: Delegate work to coworker" not in output.log
+        ):
+            memory = ShortTermMemoryItem(
+                data=output.log,
+                agent=self.crew_agent.role,
+                metadata={
+                    "observation": self.task.description,
+                },
+            )
+            self.crew._short_term_memory.save(memory)
+
+    def _create_long_term_memory(self, output) -> None:
+        if self.crew and self.crew.memory:
+            ltm_agent = TaskEvaluator(self.crew_agent)
+            evaluation = ltm_agent.evaluate(self.task, output.log)
+
+            if isinstance(evaluation, ConverterError):
+                return
+
+            long_term_memory = LongTermMemoryItem(
+                task=self.task.description,
+                agent=self.crew_agent.role,
+                quality=evaluation.quality,
+                datetime=str(time.time()),
+                expected_output=self.task.expected_output,
+                metadata={
+                    "suggestions": evaluation.suggestions,
+                    "quality": evaluation.quality,
+                },
+            )
+            self.crew._long_term_memory.save(long_term_memory)
+
+            for entity in evaluation.entities:
+                entity_memory = EntityMemoryItem(
+                    name=entity.name,
+                    type=entity.type,
+                    description=entity.description,
+                    relationships="\n".join([f"- {r}" for r in entity.relationships]),
+                )
+                self.crew._entity_memory.save(entity_memory)
+
+    def _ask_human_input(self, final_answer: dict) -> str:
+        """Get human input."""
+        return input(
+            self._i18n.slice("getting_input").format(final_answer=final_answer)
+        )

src/crewai/agents/agent_builder/utilities/base_agent_tool.py

@@ -0,0 +1,81 @@
+from abc import ABC, abstractmethod
+from typing import List, Optional, Union
+from pydantic import BaseModel, Field
+from crewai.agents.agent_builder.base_agent import BaseAgent
+from crewai.task import Task
+from crewai.utilities import I18N
+
+
+class BaseAgentTools(BaseModel, ABC):
+    """Default tools around agent delegation"""
+
+    agents: List[BaseAgent] = Field(description="List of agents in this crew.")
+    i18n: I18N = Field(default=I18N(), description="Internationalization settings.")
+
+    @abstractmethod
+    def tools(self):
+        pass
+
+    def _get_coworker(self, coworker: Optional[str], **kwargs) -> Optional[str]:
+        coworker = coworker or kwargs.get("co_worker") or kwargs.get("coworker")
+        if coworker:
+            is_list = coworker.startswith("[") and coworker.endswith("]")
+            if is_list:
+                coworker = coworker[1:-1].split(",")[0]
+        return coworker
+
+    def delegate_work(
+        self, task: str, context: str, coworker: Optional[str] = None, **kwargs
+    ):
+        """Useful to delegate a specific task to a coworker passing all necessary context and names."""
+        coworker = self._get_coworker(coworker, **kwargs)
+        return self._execute(coworker, task, context)
+
+    def ask_question(
+        self, question: str, context: str, coworker: Optional[str] = None, **kwargs
+    ):
+        """Useful to ask a question, opinion or take from a coworker passing all necessary context and names."""
+        coworker = self._get_coworker(coworker, **kwargs)
+        return self._execute(coworker, question, context)
+
+    def _execute(self, agent: Union[str, None], task: str, context: Union[str, None]):
+        """Execute the command."""
+        try:
+            if agent is None:
+                agent = ""
+
+            # It is important to remove the quotes from the agent name.
+            # The reason we have to do this is because less-powerful LLM's
+            # have difficulty producing valid JSON.
+            # As a result, we end up with invalid JSON that is truncated like this:
+            # {"task": "....", "coworker": "....
+            # when it should look like this:
+            # {"task": "....", "coworker": "...."}
+            agent_name = agent.casefold().replace('"', "").replace("\n", "")
+
+            agent = [
+                available_agent
+                for available_agent in self.agents
+                if available_agent.role.casefold().replace("\n", "") == agent_name
+            ]
+        except Exception as _:
+            return self.i18n.errors("agent_tool_unexsiting_coworker").format(
+                coworkers="\n".join(
+                    [f"- {agent.role.casefold()}" for agent in self.agents]
+                )
+            )
+
+        if not agent:
+            return self.i18n.errors("agent_tool_unexsiting_coworker").format(
+                coworkers="\n".join(
+                    [f"- {agent.role.casefold()}" for agent in self.agents]
+                )
+            )
+
+        agent = agent[0]
+        task = Task(
+            description=task,
+            agent=agent,
+            expected_output="Your best answer to your coworker asking you this, accounting for the context shared.",
+        )
+        return agent.execute_task(task, context)

src/crewai/agents/agent_builder/utilities/base_output_converter_base.py

@@ -0,0 +1,48 @@
+from abc import ABC, abstractmethod
+from typing import Any, Optional
+
+
+from pydantic import BaseModel, Field, PrivateAttr
+
+
+class OutputConverter(BaseModel, ABC):
+    """
+    Abstract base class for converting task results into structured formats.
+
+    This class provides a framework for converting unstructured text into
+    either Pydantic models or JSON, tailored for specific agent requirements.
+    It uses a language model to interpret and structure the input text based
+    on given instructions.
+
+    Attributes:
+        text (str): The input text to be converted.
+        llm (Any): The language model used for conversion.
+        model (Any): The target model for structuring the output.
+        instructions (str): Specific instructions for the conversion process.
+        max_attempts (int): Maximum number of conversion attempts (default: 3).
+    """
+
+    _is_gpt: bool = PrivateAttr(default=True)
+    text: str = Field(description="Text to be converted.")
+    llm: Any = Field(description="The language model to be used to convert the text.")
+    model: Any = Field(description="The model to be used to convert the text.")
+    instructions: str = Field(description="Conversion instructions to the LLM.")
+    max_attemps: Optional[int] = Field(
+        description="Max number of attemps to try to get the output formated.",
+        default=3,
+    )
+
+    @abstractmethod
+    def to_pydantic(self, current_attempt=1):
+        """Convert text to pydantic."""
+        pass
+
+    @abstractmethod
+    def to_json(self, current_attempt=1):
+        """Convert text to json."""
+        pass
+
+    @abstractmethod
+    def _is_gpt(self, llm):
+        """Return if llm provided is of gpt from openai."""
+        pass

src/crewai/agents/agent_builder/utilities/base_token_process.py

@@ -0,0 +1,27 @@
+from typing import Any, Dict
+
+
+class TokenProcess:
+    total_tokens: int = 0
+    prompt_tokens: int = 0
+    completion_tokens: int = 0
+    successful_requests: int = 0
+
+    def sum_prompt_tokens(self, tokens: int):
+        self.prompt_tokens = self.prompt_tokens + tokens
+        self.total_tokens = self.total_tokens + tokens
+
+    def sum_completion_tokens(self, tokens: int):
+        self.completion_tokens = self.completion_tokens + tokens
+        self.total_tokens = self.total_tokens + tokens
+
+    def sum_successful_requests(self, requests: int):
+        self.successful_requests = self.successful_requests + requests
+
+    def get_summary(self) -> Dict[str, Any]:
+        return {
+            "total_tokens": self.total_tokens,
+            "prompt_tokens": self.prompt_tokens,
+            "completion_tokens": self.completion_tokens,
+            "successful_requests": self.successful_requests,
+        }

src/crewai/agents/executor.py

@@ -7,24 +7,20 @@ from langchain.agents.agent import ExceptionTool
 from langchain.callbacks.manager import CallbackManagerForChainRun
 from langchain_core.agents import AgentAction, AgentFinish, AgentStep
 from langchain_core.exceptions import OutputParserException
-from langchain_core.pydantic_v1 import root_validator
+
 from langchain_core.tools import BaseTool
 from langchain_core.utils.input import get_color_mapping
 from pydantic import InstanceOf
+from crewai.agents.agent_builder.base_agent_executor_mixin import CrewAgentExecutorMixin
 
 from crewai.agents.tools_handler import ToolsHandler
-from crewai.memory.entity.entity_memory_item import EntityMemoryItem
-from crewai.memory.long_term.long_term_memory_item import LongTermMemoryItem
-from crewai.memory.short_term.short_term_memory_item import ShortTermMemoryItem
 from crewai.tools.tool_usage import ToolUsage, ToolUsageErrorException
 from crewai.utilities import I18N
 from crewai.utilities.constants import TRAINING_DATA_FILE
-from crewai.utilities.converter import ConverterError
-from crewai.utilities.evaluators.task_evaluator import TaskEvaluator
 from crewai.utilities.training_handler import CrewTrainingHandler
 
 
-class CrewAgentExecutor(AgentExecutor):
+class CrewAgentExecutor(AgentExecutor, CrewAgentExecutorMixin):
     _i18n: I18N = I18N()
     should_ask_for_human_input: bool = False
     llm: Any = None
@@ -46,61 +42,6 @@ class CrewAgentExecutor(AgentExecutor):
     prompt_template: Optional[str] = None
     response_template: Optional[str] = None
 
-    @root_validator()
-    def set_force_answer_max_iterations(cls, values: Dict) -> Dict:
-        values["force_answer_max_iterations"] = values["max_iterations"] - 2
-        return values
-
-    def _should_force_answer(self) -> bool:
-        return (
-            self.iterations == self.force_answer_max_iterations
-        ) and not self.have_forced_answer
-
-    def _create_short_term_memory(self, output) -> None:
-        if (
-            self.crew
-            and self.crew.memory
-            and "Action: Delegate work to coworker" not in output.log
-        ):
-            memory = ShortTermMemoryItem(
-                data=output.log,
-                agent=self.crew_agent.role,
-                metadata={
-                    "observation": self.task.description,
-                },
-            )
-            self.crew._short_term_memory.save(memory)
-
-    def _create_long_term_memory(self, output) -> None:
-        if self.crew and self.crew.memory:
-            ltm_agent = TaskEvaluator(self.crew_agent)
-            evaluation = ltm_agent.evaluate(self.task, output.log)
-
-            if isinstance(evaluation, ConverterError):
-                return
-
-            long_term_memory = LongTermMemoryItem(
-                task=self.task.description,
-                agent=self.crew_agent.role,
-                quality=evaluation.quality,
-                datetime=str(time.time()),
-                expected_output=self.task.expected_output,
-                metadata={
-                    "suggestions": evaluation.suggestions,
-                    "quality": evaluation.quality,
-                },
-            )
-            self.crew._long_term_memory.save(long_term_memory)
-
-            for entity in evaluation.entities:
-                entity_memory = EntityMemoryItem(
-                    name=entity.name,
-                    type=entity.type,
-                    description=entity.description,
-                    relationships="\n".join([f"- {r}" for r in entity.relationships]),
-                )
-                self.crew._entity_memory.save(entity_memory)
-
     def _call(
         self,
         inputs: Dict[str, str],
@@ -310,12 +251,6 @@ class CrewAgentExecutor(AgentExecutor):
                     )
             yield AgentStep(action=agent_action, observation=observation)
 
-    def _ask_human_input(self, final_answer: dict) -> str:
-        """Get human input."""
-        return input(
-            self._i18n.slice("getting_input").format(final_answer=final_answer)
-        )
-
     def _handle_crew_training_output(
         self, output: AgentFinish, human_feedback: str | None = None
     ) -> None:

src/crewai/crew.py

@@ -18,6 +18,7 @@ from pydantic import (
 from pydantic_core import PydanticCustomError
 
 from crewai.agent import Agent
+from crewai.agents.agent_builder.base_agent import BaseAgent
 from crewai.agents.cache import CacheHandler
 from crewai.memory.entity.entity_memory import EntityMemory
 from crewai.memory.long_term.long_term_memory import LongTermMemory
@@ -71,7 +72,7 @@ class Crew(BaseModel):
     cache: bool = Field(default=True)
     model_config = ConfigDict(arbitrary_types_allowed=True)
     tasks: List[Task] = Field(default_factory=list)
-    agents: List[Agent] = Field(default_factory=list)
+    agents: List[BaseAgent] = Field(default_factory=list)
     process: Process = Field(default=Process.sequential)
     verbose: Union[int, bool] = Field(default=0)
     memory: bool = Field(
@@ -93,7 +94,7 @@ class Crew(BaseModel):
     manager_llm: Optional[Any] = Field(
         description="Language model that will run the agent.", default=None
     )
-    manager_agent: Optional[Any] = Field(
+    manager_agent: Optional[BaseAgent] = Field(
         description="Custom agent that will be used as manager.", default=None
     )
     manager_callbacks: Optional[List[InstanceOf[BaseCallbackHandler]]] = Field(
@@ -288,12 +289,17 @@ class Crew(BaseModel):
         i18n = I18N(prompt_file=self.prompt_file)
 
         for agent in self.agents:
+            # type: ignore # Argument 1 to "_interpolate_inputs" of "Crew" has incompatible type "dict[str, Any] | None"; expected "dict[str, Any]"
             agent.i18n = i18n
-            agent.crew = self
-
-            if not agent.function_calling_llm:
+            # type: ignore[attr-defined] # Argument 1 to "_interpolate_inputs" of "Crew" has incompatible type "dict[str, Any] | None"; expected "dict[str, Any]"
+            agent.crew = self  # type: ignore[attr-defined]
+            # TODO: Create an AgentFunctionCalling protocol for future refactoring
+            if (
+                hasattr(agent, "function_calling_llm")
+                and not agent.function_calling_llm
+            ):
                 agent.function_calling_llm = self.function_calling_llm
-            if not agent.step_callback:
+            if hasattr(agent, "step_callback") and not agent.step_callback:
                 agent.step_callback = self.step_callback
 
             agent.create_agent_executor()
@@ -311,10 +317,10 @@ class Crew(BaseModel):
             raise NotImplementedError(
                 f"The process '{self.process}' is not implemented yet."
             )
-
         metrics = metrics + [
             agent._token_process.get_summary() for agent in self.agents
         ]
+
         self.usage_metrics = {
             key: sum([m[key] for m in metrics if m is not None]) for key in metrics[0]
         }
@@ -364,13 +370,14 @@ class Crew(BaseModel):
     def _run_sequential_process(self) -> str:
         """Executes tasks sequentially and returns the final output."""
         task_output = ""
+        token_usage = []
         for task in self.tasks:
             if task.agent.allow_delegation:  # type: ignore #  Item "None" of "Agent | None" has no attribute "allow_delegation"
                 agents_for_delegation = [
                     agent for agent in self.agents if agent != task.agent
                 ]
                 if len(self.agents) > 1 and len(agents_for_delegation) > 0:
-                    task.tools += AgentTools(agents=agents_for_delegation).tools()
+                    task.tools += task.agent.get_delegation_tools(agents_for_delegation)
 
             role = task.agent.role if task.agent is not None else "None"
             self._logger.log("debug", f"== Working Agent: {role}", color="bold_purple")
@@ -382,7 +389,6 @@ class Crew(BaseModel):
                 self._file_handler.log(
                     agent=role, task=task.description, status="started"
                 )
-
             output = task.execute(context=task_output)
 
             if not task.async_execution:
@@ -390,15 +396,18 @@ class Crew(BaseModel):
 
             role = task.agent.role if task.agent is not None else "None"
             self._logger.log("debug", f"== [{role}] Task output: {task_output}\n\n")
+            token_summ = task.agent._token_process.get_summary()
+
+            token_usage.append(token_summ)
 
             if self.output_log_file:
                 self._file_handler.log(agent=role, task=task_output, status="completed")
 
+        token_usage_formatted = self.aggregate_token_usage(token_usage)
         self._finish_execution(task_output)
-        # type: ignore # Item "None" of "Agent | None" has no attribute "_token_process"
-        token_usage = task.agent._token_process.get_summary()
+
         # type: ignore # Incompatible return value type (got "tuple[str, Any]", expected "str")
-        return self._format_output(task_output, token_usage)
+        return self._format_output(task_output, token_usage_formatted)
 
     def _run_hierarchical_process(self) -> Union[str, Dict[str, Any]]:
         """Creates and assigns a manager agent to make sure the crew completes the tasks."""
@@ -409,7 +418,7 @@ class Crew(BaseModel):
             manager = self.manager_agent
             if len(manager.tools) > 0:
                 raise Exception("Manager agent should not have tools")
-            manager.tools = AgentTools(agents=self.agents).tools()
+            manager.tools = self.manager_agent.get_delegation_tools(self.agents)
         else:
             manager = Agent(
                 role=i18n.retrieve("hierarchical_manager_agent", "role"),
@@ -421,6 +430,7 @@ class Crew(BaseModel):
             )
 
         task_output = ""
+        token_usage = []
         for task in self.tasks:
             self._logger.log("debug", f"Working Agent: {manager.role}")
             self._logger.log("info", f"Starting Task: {task.description}")
@@ -435,17 +445,23 @@ class Crew(BaseModel):
             )
 
             self._logger.log("debug", f"[{manager.role}] Task output: {task_output}")
-
+            if hasattr(task, "agent._token_process"):
+                token_summ = task.agent._token_process.get_summary()
+                token_usage.append(token_summ)
             if self.output_log_file:
                 self._file_handler.log(
                     agent=manager.role, task=task_output, status="completed"
                 )
 
         self._finish_execution(task_output)
+
         # type: ignore # Incompatible return value type (got "tuple[str, Any]", expected "str")
         manager_token_usage = manager._token_process.get_summary()
+        token_usage.append(manager_token_usage)
+        token_usage_formatted = self.aggregate_token_usage(token_usage)
+
         return self._format_output(
-            task_output, manager_token_usage
+            task_output, token_usage_formatted
         ), manager_token_usage
 
     def copy(self):
@@ -494,10 +510,11 @@ class Crew(BaseModel):
             for task in self.tasks
         ]
         # type: ignore # "interpolate_inputs" of "Agent" does not return a value (it only ever returns None)
-        [agent.interpolate_inputs(inputs) for agent in self.agents]
+        for agent in self.agents:
+            agent.interpolate_inputs(inputs)
 
     def _format_output(
-        self, output: str, token_usage: Optional[Dict[str, Any]]
+        self, output: str, token_usage: Optional[Dict[str, Any]] = None
     ) -> Union[str, Dict[str, Any]]:
         """
         Formats the output of the crew execution.
@@ -519,3 +536,9 @@ class Crew(BaseModel):
 
     def __repr__(self):
         return f"Crew(id={self.id}, process={self.process}, number_of_agents={len(self.agents)}, number_of_tasks={len(self.tasks)})"
+
+    def aggregate_token_usage(self, token_usage_list: List[Dict[str, Any]]):
+        return {
+            key: sum([m[key] for m in token_usage_list if m is not None])
+            for key in token_usage_list[0]
+        }

src/crewai/task.py

@@ -9,10 +9,10 @@ from langchain_openai import ChatOpenAI
 from pydantic import UUID4, BaseModel, Field, field_validator, model_validator
 from pydantic_core import PydanticCustomError
 
-from crewai.agent import Agent
 from crewai.tasks.task_output import TaskOutput
-from crewai.utilities import I18N, Converter, ConverterError, Printer
+from crewai.utilities import I18N, ConverterError, Printer
 from crewai.utilities.pydantic_schema_parser import PydanticSchemaParser
+from crewai.agents.agent_builder.base_agent import BaseAgent
 
 
 class Task(BaseModel):
@@ -55,7 +55,7 @@ class Task(BaseModel):
     callback: Optional[Any] = Field(
         description="Callback to be executed after the task is completed.", default=None
     )
-    agent: Optional[Agent] = Field(
+    agent: Optional[BaseAgent] = Field(
         description="Agent responsible for execution the task.", default=None
     )
     context: Optional[List["Task"]] = Field(
@@ -147,7 +147,7 @@ class Task(BaseModel):
 
     def execute(  # type: ignore # Missing return statement
         self,
-        agent: Agent | None = None,
+        agent: BaseAgent | None = None,
         context: Optional[str] = None,
         tools: Optional[List[Any]] = None,
     ) -> str:
@@ -198,9 +198,9 @@ class Task(BaseModel):
             context=context,
             tools=tools,
         )
-
         exported_output = self._export_output(result)
 
+        # type: the responses are usually str but need to figuire out a more elegant solution here
         self.output = TaskOutput(
             description=self.description,
             exported_output=exported_output,
@@ -262,7 +262,7 @@ class Task(BaseModel):
             [task.copy() for task in self.context] if self.context else None
         )
         cloned_agent = self.agent.copy() if self.agent else None
-        cloned_tools = deepcopy(self.tools) if self.tools else None
+        cloned_tools = deepcopy(self.tools) if self.tools else []
 
         copied_task = Task(
             **copied_data,
@@ -302,14 +302,13 @@ class Task(BaseModel):
                         pass
 
             # type: ignore # Item "None" of "Agent | None" has no attribute "function_calling_llm"
-            llm = self.agent.function_calling_llm or self.agent.llm
-
+            llm = getattr(self.agent, "function_calling_llm", None) or self.agent.llm
             if not self._is_gpt(llm):
                 # 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(
+            converter = self.agent.get_output_converter(
                 llm=llm, text=result, model=model, instructions=instructions
             )
 

src/crewai/tools/agent_tools.py

@@ -1,106 +1,25 @@
-from typing import List, Union
-
 from langchain.tools import StructuredTool
-from pydantic import BaseModel, Field
 
-from crewai.agent import Agent
-from crewai.task import Task
-from crewai.utilities import I18N
+from crewai.agents.agent_builder.utilities.base_agent_tool import BaseAgentTools
 
 
-class AgentTools(BaseModel):
+class AgentTools(BaseAgentTools):
     """Default tools around agent delegation"""
 
-    agents: List[Agent] = Field(description="List of agents in this crew.")
-    i18n: I18N = Field(default=I18N(), description="Internationalization settings.")
-
     def tools(self):
+        coworkers = f"[{', '.join([f'{agent.role}' for agent in self.agents])}]"
         tools = [
             StructuredTool.from_function(
                 func=self.delegate_work,
                 name="Delegate work to coworker",
                 description=self.i18n.tools("delegate_work").format(
-                    coworkers=f"[{', '.join([f'{agent.role}' for agent in self.agents])}]"
+                    coworkers=coworkers
                 ),
             ),
             StructuredTool.from_function(
                 func=self.ask_question,
                 name="Ask question to coworker",
-                description=self.i18n.tools("ask_question").format(
-                    coworkers=f"[{', '.join([f'{agent.role}' for agent in self.agents])}]"
-                ),
+                description=self.i18n.tools("ask_question").format(coworkers=coworkers),
             ),
         ]
         return tools
-
-    def delegate_work(
-        self,
-        task: str,
-        context: Union[str, None] = None,
-        coworker: Union[str, None] = None,
-        **kwargs,
-    ):
-        """Useful to delegate a specific task to a coworker passing all necessary context and names."""
-        coworker = coworker or kwargs.get("co_worker") or kwargs.get("coworker")
-        if coworker:
-            is_list = coworker.startswith("[") and coworker.endswith("]")
-            if is_list:
-                coworker = coworker[1:-1].split(",")[0]
-        return self._execute(coworker, task, context)
-
-    def ask_question(
-        self,
-        question: str,
-        context: Union[str, None] = None,
-        coworker: Union[str, None] = None,
-        **kwargs,
-    ):
-        """Useful to ask a question, opinion or take from a coworker passing all necessary context and names."""
-        coworker = coworker or kwargs.get("co_worker") or kwargs.get("coworker")
-        if coworker:
-            is_list = coworker.startswith("[") and coworker.endswith("]")
-            if is_list:
-                coworker = coworker[1:-1].split(",")[0]
-        return self._execute(coworker, question, context)
-
-    def _execute(self, agent: Union[str, None], task: str, context: Union[str, None]):
-        """Execute the command."""
-        try:
-            if agent is None:
-                agent = ""
-
-            # It is important to remove the quotes from the agent name.
-            # The reason we have to do this is because less-powerful LLM's
-            # have difficulty producing valid JSON.
-            # As a result, we end up with invalid JSON that is truncated like this:
-            # {"task": "....", "coworker": "....
-            # when it should look like this:
-            # {"task": "....", "coworker": "...."}
-            agent_name = agent.casefold().replace('"', "").replace("\n", "")
-
-            agent = [
-                available_agent
-                for available_agent in self.agents
-                if available_agent.role.casefold().replace("\n", "") == agent_name
-            ]
-        except Exception as _:
-            return self.i18n.errors("agent_tool_unexsiting_coworker").format(
-                coworkers="\n".join(
-                    [f"- {agent.role.casefold()}" for agent in self.agents]
-                )
-            )
-
-        if not agent:
-            return self.i18n.errors("agent_tool_unexsiting_coworker").format(
-                coworkers="\n".join(
-                    [f"- {agent.role.casefold()}" for agent in self.agents]
-                )
-            )
-
-        agent = agent[0]
-        task = Task(
-            description=task,
-            agent=agent,
-            expected_output="Your best answer to your coworker asking you this, accounting for the context shared.",
-        )
-        return agent.execute_task(task, context)

src/crewai/utilities/converter.py

@@ -1,9 +1,11 @@
 import json
-from typing import Any, Optional
 
 from langchain.schema import HumanMessage, SystemMessage
 from langchain_openai import ChatOpenAI
-from pydantic import BaseModel, Field, PrivateAttr, model_validator
+from pydantic import model_validator
+from crewai.agents.agent_builder.utilities.base_output_converter_base import (
+    OutputConverter,
+)
 
 
 class ConverterError(Exception):
@@ -14,19 +16,9 @@ class ConverterError(Exception):
         self.message = message
 
 
-class Converter(BaseModel):
+class Converter(OutputConverter):
     """Class that converts text into either pydantic or json."""
 
-    _is_gpt: bool = PrivateAttr(default=True)
-    text: str = Field(description="Text to be converted.")
-    llm: Any = Field(description="The language model to be used to convert the text.")
-    model: Any = Field(description="The model to be used to convert the text.")
-    instructions: str = Field(description="Conversion instructions to the LLM.")
-    max_attemps: Optional[int] = Field(
-        description="Max number of attemps to try to get the output formated.",
-        default=3,
-    )
-
     @model_validator(mode="after")
     def check_llm_provider(self):
         if not self._is_gpt(self.llm):

src/crewai/utilities/token_counter_callback.py

@@ -4,31 +4,7 @@ import tiktoken
 from langchain.callbacks.base import BaseCallbackHandler
 from langchain.schema import LLMResult
 
-
-class TokenProcess:
-    total_tokens: int = 0
-    prompt_tokens: int = 0
-    completion_tokens: int = 0
-    successful_requests: int = 0
-
-    def sum_prompt_tokens(self, tokens: int):
-        self.prompt_tokens = self.prompt_tokens + tokens
-        self.total_tokens = self.total_tokens + tokens
-
-    def sum_completion_tokens(self, tokens: int):
-        self.completion_tokens = self.completion_tokens + tokens
-        self.total_tokens = self.total_tokens + tokens
-
-    def sum_successful_requests(self, requests: int):
-        self.successful_requests = self.successful_requests + requests
-
-    def get_summary(self) -> Dict[str, Any]:
-        return {
-            "total_tokens": self.total_tokens,
-            "prompt_tokens": self.prompt_tokens,
-            "completion_tokens": self.completion_tokens,
-            "successful_requests": self.successful_requests,
-        }
+from crewai.agents.agent_builder.utilities.base_token_process import TokenProcess
 
 
 class TokenCalcHandler(BaseCallbackHandler):