code: import os
  import uuid
  from typing import Any, Dict, List, Optional, Tuple
  
  from langchain.agents.agent import RunnableAgent
  from langchain.agents.tools import tool as LangChainTool
  from langchain.memory import ConversationSummaryMemory
  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 crewai.utilities import I18N, Logger, Prompts, RPMController
  from crewai.utilities.token_counter_callback import TokenCalcHandler, TokenProcess
  
  
  class Agent(BaseModel):
      """Represents an agent in a system.
  
      Each agent has a role, a goal, a backstory, and an optional language model (llm).
      The agent can also have memory, can operate in verbose mode, and can delegate tasks to other agents.
  
      Attributes:
              agent_executor: An instance of the CrewAgentExecutor class.
              role: The role of the agent.
              goal: The objective of the agent.
              backstory: The backstory of the agent.
              config: Dict representation of agent configuration.
              llm: The language model that will run the agent.
              function_calling_llm: The language model that will the tool calling for this agent, it overrides the crew function_calling_llm.
              max_iter: Maximum number of iterations for an agent to execute a task.
              memory: Whether the agent should have memory or not.
              max_rpm: Maximum number of requests per minute for the agent execution to be respected.
              verbose: Whether the agent execution should be in verbose mode.
              allow_delegation: Whether the agent is allowed to delegate tasks to other agents.
              tools: Tools at agents disposal
              step_callback: Callback to be executed after each step of the agent execution.
              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")
      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.",
      )
      memory: bool = Field(
          default=False, description="Whether the agent should have memory or not"
      )
      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=15, description="Maximum iterations for an agent to execute a task"
      )
      agent_executor: InstanceOf[CrewAgentExecutor] = Field(
          default=None, description="An instance of the CrewAgentExecutor class."
      )
      tools_handler: InstanceOf[ToolsHandler] = Field(
          default=None, description="An instance of the ToolsHandler class."
      )
      cache_handler: InstanceOf[CacheHandler] = Field(
          default=CacheHandler(), description="An instance of the CacheHandler class."
      )
      step_callback: Optional[Any] = Field(
          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-4")
          ),
          description="Language model that will run the agent.",
      )
      function_calling_llm: Optional[Any] = Field(
          description="Language model that will run the agent.", default=None
      )
      callbacks: Optional[List[InstanceOf[BaseCallbackHandler]]] = Field(
          default=None, description="Callback to be executed"
      )
  
      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."""
          if hasattr(self.llm, "model_name"):
              self.llm.callbacks = [
                  TokenCalcHandler(self.llm.model_name, self._token_process)
              ]
          if not self.agent_executor:
              self.set_cache_handler(self.cache_handler)
          return self
  
      def execute_task(
          self,
          task: Any,
          context: Optional[str] = None,
          tools: Optional[List[Any]] = None,
      ) -> str:
          """Execute a task with the agent.
  
          Args:
              task: Task to execute.
              context: Context to execute the task in.
              tools: Tools to use for the task.
  
          Returns:
              Output of the agent
          """
          self.tools_handler.last_used_tool = {}
  
          task_prompt = task.prompt()
  
          if context:
              task_prompt = self.i18n.slice("task_with_context").format(
                  task=task_prompt, context=context
              )
  
          tools = self._parse_tools(tools or self.tools)
          self.create_agent_executor(tools=tools)
          self.agent_executor.tools = tools
          self.agent_executor.task = task
  
          self.agent_executor.tools_description = render_text_description(tools)
          self.agent_executor.tools_names = self.__tools_names(tools)
  
          result = self.agent_executor.invoke(
              {
                  "input": task_prompt,
                  "tool_names": self.agent_executor.tools_names,
                  "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.cache_handler = cache_handler
          self.tools_handler = ToolsHandler(cache=self.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 create_agent_executor(self, tools=None) -> None:
          """Create an agent executor for the agent.
  
          Returns:
              An instance of the CrewAgentExecutor class.
          """
          tools = tools or self.tools
  
          agent_args = {
              "input": lambda x: x["input"],
              "tools": lambda x: x["tools"],
              "tool_names": lambda x: x["tool_names"],
              "agent_scratchpad": lambda x: self.format_log_to_str(
                  x["intermediate_steps"]
              ),
          }
  
          executor_args = {
              "llm": self.llm,
              "i18n": self.i18n,
              "tools": self._parse_tools(tools),
              "verbose": self.verbose,
              "handle_parsing_errors": True,
              "max_iterations": self.max_iter,
              "step_callback": self.step_callback,
              "tools_handler": self.tools_handler,
              "function_calling_llm": self.function_calling_llm,
              "callbacks": self.callbacks,
          }
  
          if self._rpm_controller:
              executor_args[
                  "request_within_rpm_limit"
              ] = self._rpm_controller.check_or_wait
  
          if self.memory:
              summary_memory = ConversationSummaryMemory(
                  llm=self.llm, input_key="input", memory_key="chat_history"
              )
              executor_args["memory"] = summary_memory
              agent_args["chat_history"] = lambda x: x["chat_history"]
              prompt = Prompts(i18n=self.i18n, tools=tools).task_execution_with_memory()
          else:
              prompt = Prompts(i18n=self.i18n, tools=tools).task_execution()
  
          execution_prompt = prompt.partial(
              goal=self.goal,
              role=self.role,
              backstory=self.backstory,
          )
  
          bind = self.llm.bind(stop=[self.i18n.slice("observation")])
          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 inputs:
              self.role = self.role.format(**inputs)
              self.goal = self.goal.format(**inputs)
              self.backstory = self.backstory.format(**inputs)
  
      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 _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:
              from crewai_tools import BaseTool as CrewAITool
  
              for tool in tools:
                  if isinstance(tool, CrewAITool):
                      tools_list.append(tool.to_langchain())
                  else:
                      tools_list.append(tool)
          except ModuleNotFoundError:
              for tool in tools:
                  tools_list.append(tool)
          return tools_list
  
      @staticmethod
      def __tools_names(tools) -> str:
          return ", ".join([t.name for t in tools])
  
      def __repr__(self):
          return f"Agent(role={self.role}, goal={self.goal}, backstory={self.backstory})"
  
apis: langchain.tools.render.render_text_description langchain.agents.agent.RunnableAgent langchain.memory.ConversationSummaryMemory
extract_api: [((2392, 2405), 'pydantic.PrivateAttr', 'PrivateAttr', ([], {}), '()\n', (2403, 2405), False, 'from pydantic import UUID4, BaseModel, ConfigDict, Field, InstanceOf, PrivateAttr, field_validator, model_validator\n'), ((2443, 2468), 'pydantic.PrivateAttr', 'PrivateAttr', ([], {'default': 'None'}), '(default=None)\n', (2454, 2468), False, 'from pydantic import UUID4, BaseModel, ConfigDict, Field, InstanceOf, PrivateAttr, field_validator, model_validator\n'), ((2506, 2531), 'pydantic.PrivateAttr', 'PrivateAttr', ([], {'default': 'None'}), '(default=None)\n', (2517, 2531), False, 'from pydantic import UUID4, BaseModel, ConfigDict, Field, InstanceOf, PrivateAttr, field_validator, model_validator\n'), ((2567, 2581), 'crewai.utilities.token_counter_callback.TokenProcess', 'TokenProcess', ([], {}), '()\n', (2579, 2581), False, 'from crewai.utilities.token_counter_callback import TokenCalcHandler, TokenProcess\n'), ((2633, 2673), 'pydantic.ConfigDict', 'ConfigDict', ([], {'arbitrary_types_allowed': '(True)'}), '(arbitrary_types_allowed=True)\n', (2643, 2673), False, 'from pydantic import UUID4, BaseModel, ConfigDict, Field, InstanceOf, PrivateAttr, field_validator, model_validator\n'), ((2690, 2807), 'pydantic.Field', 'Field', ([], {'default_factory': 'uuid.uuid4', 'frozen': '(True)', 'description': '"""Unique identifier for the object, not set by user."""'}), "(default_factory=uuid.uuid4, frozen=True, description=\n    'Unique identifier for the object, not set by user.')\n", (2695, 2807), False, 'from pydantic import UUID4, BaseModel, ConfigDict, Field, InstanceOf, PrivateAttr, field_validator, model_validator\n'), ((2850, 2888), 'pydantic.Field', 'Field', ([], {'description': '"""Role of the agent"""'}), "(description='Role of the agent')\n", (2855, 2888), False, 'from pydantic import UUID4, BaseModel, ConfigDict, Field, InstanceOf, PrivateAttr, field_validator, model_validator\n'), ((2905, 2948), 'pydantic.Field', 'Field', ([], {'description': '"""Objective of the agent"""'}), "(description='Objective of the agent')\n", (2910, 2948), False, 'from pydantic import UUID4, BaseModel, ConfigDict, Field, InstanceOf, PrivateAttr, field_validator, model_validator\n'), ((2970, 3013), 'pydantic.Field', 'Field', ([], {'description': '"""Backstory of the agent"""'}), "(description='Backstory of the agent')\n", (2975, 3013), False, 'from pydantic import UUID4, BaseModel, ConfigDict, Field, InstanceOf, PrivateAttr, field_validator, model_validator\n'), ((3053, 3115), 'pydantic.Field', 'Field', ([], {'description': '"""Configuration for the agent"""', 'default': 'None'}), "(description='Configuration for the agent', default=None)\n", (3058, 3115), False, 'from pydantic import UUID4, BaseModel, ConfigDict, Field, InstanceOf, PrivateAttr, field_validator, model_validator\n'), ((3168, 3291), 'pydantic.Field', 'Field', ([], {'default': 'None', 'description': '"""Maximum number of requests per minute for the agent execution to be respected."""'}), "(default=None, description=\n    'Maximum number of requests per minute for the agent execution to be respected.'\n    )\n", (3173, 3291), False, 'from pydantic import UUID4, BaseModel, ConfigDict, Field, InstanceOf, PrivateAttr, field_validator, model_validator\n'), ((3324, 3403), 'pydantic.Field', 'Field', ([], {'default': '(False)', 'description': '"""Whether the agent should have memory or not"""'}), "(default=False, description='Whether the agent should have memory or not')\n", (3329, 3403), False, 'from pydantic import UUID4, BaseModel, ConfigDict, Field, InstanceOf, PrivateAttr, field_validator, model_validator\n'), ((3438, 3510), 'pydantic.Field', 'Field', ([], {'default': '(False)', 'description': '"""Verbose mode for the Agent Execution"""'}), "(default=False, description='Verbose mode for the Agent Execution')\n", (3443, 3510), False, 'from pydantic import UUID4, BaseModel, ConfigDict, Field, InstanceOf, PrivateAttr, field_validator, model_validator\n'), ((3554, 3624), 'pydantic.Field', 'Field', ([], {'default': '(True)', 'description': '"""Allow delegation of tasks to agents"""'}), "(default=True, description='Allow delegation of tasks to agents')\n", (3559, 3624), False, 'from pydantic import UUID4, BaseModel, ConfigDict, Field, InstanceOf, PrivateAttr, field_validator, model_validator\n'), ((3672, 3739), 'pydantic.Field', 'Field', ([], {'default_factory': 'list', 'description': '"""Tools at agents disposal"""'}), "(default_factory=list, description='Tools at agents disposal')\n", (3677, 3739), False, 'from pydantic import UUID4, BaseModel, ConfigDict, Field, InstanceOf, PrivateAttr, field_validator, model_validator\n'), ((3784, 3871), 'pydantic.Field', 'Field', ([], {'default': '(15)', 'description': '"""Maximum iterations for an agent to execute a task"""'}), "(default=15, description=\n    'Maximum iterations for an agent to execute a task')\n", (3789, 3871), False, 'from pydantic import UUID4, BaseModel, ConfigDict, Field, InstanceOf, PrivateAttr, field_validator, model_validator\n'), ((3933, 4011), 'pydantic.Field', 'Field', ([], {'default': 'None', 'description': '"""An instance of the CrewAgentExecutor class."""'}), "(default=None, description='An instance of the CrewAgentExecutor class.')\n", (3938, 4011), False, 'from pydantic import UUID4, BaseModel, ConfigDict, Field, InstanceOf, PrivateAttr, field_validator, model_validator\n'), ((4072, 4145), 'pydantic.Field', 'Field', ([], {'default': 'None', 'description': '"""An instance of the ToolsHandler class."""'}), "(default=None, description='An instance of the ToolsHandler class.')\n", (4077, 4145), False, 'from pydantic import UUID4, BaseModel, ConfigDict, Field, InstanceOf, PrivateAttr, field_validator, model_validator\n'), ((4339, 4442), 'pydantic.Field', 'Field', ([], {'default': 'None', 'description': '"""Callback to be executed after each step of the agent execution."""'}), "(default=None, description=\n    'Callback to be executed after each step of the agent execution.')\n", (4344, 4442), False, 'from pydantic import UUID4, BaseModel, ConfigDict, Field, InstanceOf, PrivateAttr, field_validator, model_validator\n'), ((4797, 4871), 'pydantic.Field', 'Field', ([], {'description': '"""Language model that will run the agent."""', 'default': 'None'}), "(description='Language model that will run the agent.', default=None)\n", (4802, 4871), False, 'from pydantic import UUID4, BaseModel, ConfigDict, Field, InstanceOf, PrivateAttr, field_validator, model_validator\n'), ((4951, 5009), 'pydantic.Field', 'Field', ([], {'default': 'None', 'description': '"""Callback to be executed"""'}), "(default=None, description='Callback to be executed')\n", (4956, 5009), False, 'from pydantic import UUID4, BaseModel, ConfigDict, Field, InstanceOf, PrivateAttr, field_validator, model_validator\n'), ((5159, 5195), 'pydantic.field_validator', 'field_validator', (['"""id"""'], {'mode': '"""before"""'}), "('id', mode='before')\n", (5174, 5195), False, 'from pydantic import UUID4, BaseModel, ConfigDict, Field, InstanceOf, PrivateAttr, field_validator, model_validator\n'), ((5430, 5459), 'pydantic.model_validator', 'model_validator', ([], {'mode': '"""after"""'}), "(mode='after')\n", (5445, 5459), False, 'from pydantic import UUID4, BaseModel, ConfigDict, Field, InstanceOf, PrivateAttr, field_validator, model_validator\n'), ((5723, 5752), 'pydantic.model_validator', 'model_validator', ([], {'mode': '"""after"""'}), "(mode='after')\n", (5738, 5752), False, 'from pydantic import UUID4, BaseModel, ConfigDict, Field, InstanceOf, PrivateAttr, field_validator, model_validator\n'), ((6070, 6099), 'pydantic.model_validator', 'model_validator', ([], {'mode': '"""after"""'}), "(mode='after')\n", (6085, 6099), False, 'from pydantic import UUID4, BaseModel, ConfigDict, Field, InstanceOf, PrivateAttr, field_validator, model_validator\n'), ((5847, 5867), 'crewai.utilities.Logger', 'Logger', (['self.verbose'], {}), '(self.verbose)\n', (5853, 5867), False, 'from crewai.utilities import I18N, Logger, Prompts, RPMController\n'), ((7345, 7375), 'langchain.tools.render.render_text_description', 'render_text_description', (['tools'], {}), '(tools)\n', (7368, 7375), False, 'from langchain.tools.render import render_text_description\n'), ((8088, 8126), 'crewai.agents.ToolsHandler', 'ToolsHandler', ([], {'cache': 'self.cache_handler'}), '(cache=self.cache_handler)\n', (8100, 8126), False, 'from crewai.agents import CacheHandler, CrewAgentExecutor, CrewAgentParser, ToolsHandler\n'), ((4229, 4243), 'crewai.agents.CacheHandler', 'CacheHandler', ([], {}), '()\n', (4241, 4243), False, 'from crewai.agents import CacheHandler, CrewAgentExecutor, CrewAgentParser, ToolsHandler\n'), ((4492, 4498), 'crewai.utilities.I18N', 'I18N', ([], {}), '()\n', (4496, 4498), False, 'from crewai.utilities import I18N, Logger, Prompts, RPMController\n'), ((5305, 5397), 'pydantic_core.PydanticCustomError', 'PydanticCustomError', (['"""may_not_set_field"""', '"""This field is not to be set by the user."""', '{}'], {}), "('may_not_set_field',\n    'This field is not to be set by the user.', {})\n", (5324, 5397), False, 'from pydantic_core import PydanticCustomError\n'), ((5957, 6013), 'crewai.utilities.RPMController', 'RPMController', ([], {'max_rpm': 'self.max_rpm', 'logger': 'self._logger'}), '(max_rpm=self.max_rpm, logger=self._logger)\n', (5970, 6013), False, 'from crewai.utilities import I18N, Logger, Prompts, RPMController\n'), ((9715, 9805), 'langchain.memory.ConversationSummaryMemory', 'ConversationSummaryMemory', ([], {'llm': 'self.llm', 'input_key': '"""input"""', 'memory_key': '"""chat_history"""'}), "(llm=self.llm, input_key='input', memory_key=\n    'chat_history')\n", (9740, 9805), False, 'from langchain.memory import ConversationSummaryMemory\n'), ((10407, 10434), 'crewai.agents.CrewAgentParser', 'CrewAgentParser', ([], {'agent': 'self'}), '(agent=self)\n', (10422, 10434), False, 'from crewai.agents import CacheHandler, CrewAgentExecutor, CrewAgentParser, ToolsHandler\n'), ((6281, 6339), 'crewai.utilities.token_counter_callback.TokenCalcHandler', 'TokenCalcHandler', (['self.llm.model_name', 'self._token_process'], {}), '(self.llm.model_name, self._token_process)\n', (6297, 6339), False, 'from crewai.utilities.token_counter_callback import TokenCalcHandler, TokenProcess\n'), ((10502, 10537), 'langchain.agents.agent.RunnableAgent', 'RunnableAgent', ([], {'runnable': 'inner_agent'}), '(runnable=inner_agent)\n', (10515, 10537), False, 'from langchain.agents.agent import RunnableAgent\n'), ((9974, 10010), 'crewai.utilities.Prompts', 'Prompts', ([], {'i18n': 'self.i18n', 'tools': 'tools'}), '(i18n=self.i18n, tools=tools)\n', (9981, 10010), False, 'from crewai.utilities import I18N, Logger, Prompts, RPMController\n'), ((10075, 10111), 'crewai.utilities.Prompts', 'Prompts', ([], {'i18n': 'self.i18n', 'tools': 'tools'}), '(i18n=self.i18n, tools=tools)\n', (10082, 10111), False, 'from crewai.utilities import I18N, Logger, Prompts, RPMController\n'), ((4630, 4674), 'os.environ.get', 'os.environ.get', (['"""OPENAI_MODEL_NAME"""', '"""gpt-4"""'], {}), "('OPENAI_MODEL_NAME', 'gpt-4')\n", (4644, 4674), False, 'import os\n')]