versionhq 1.1.9.13__py3-none-any.whl → 1.1.10.2__py3-none-any.whl

versionhq/__init__.py

@@ -18,7 +18,7 @@ from versionhq.tool.model import Tool
 from versionhq.tool.composio_tool import ComposioHandler
 
 
-__version__ = "1.1.9.13"
+__version__ = "1.1.10.2"
 __all__ = [
     "Agent",
     "Customer",

versionhq/_utils/logger.py

@@ -12,8 +12,6 @@ class Printer:
             self._print_red(content)
         elif color == "green":
             self._print_green(content)
-        elif color == "purple":
-            self._print_purple(content)
         elif color == "blue":
             self._print_blue(content)
         elif color == "yellow":
@@ -27,9 +25,6 @@ class Printer:
     def _print_green(self, content):
         print("\033[1m\033[92m {}\033[00m".format(content))
 
-    def _print_purple(self, content):
-        print("\033[95m {}\033[00m".format(content))
-
     def _print_red(self, content):
         print("\033[91m {}\033[00m".format(content))
 
@@ -47,4 +42,4 @@ class Logger(BaseModel):
     def log(self, level, message, color="yellow"):
         if self.verbose:
             timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-            self._printer.print(f"\n[{timestamp}][{level.upper()}]: {message}", color=color)
+            self._printer.print(f"\n{timestamp} - versionHQ - {level.upper()}: {message}", color=color)

versionhq/_utils/process_config.py

@@ -8,19 +8,16 @@ def process_config(values_to_update: Dict[str, Any], model_class: Type[BaseModel
     Refer to the Pydantic model class for field validation.
     """
 
-    if hasattr(values_to_update, "config"):
-        config = values_to_update.pop("config", {})
-    else:
-        return values_to_update
+    config = values_to_update.pop("config", {})
 
+    if config:
+        for k, v in config.items():
+            if k not in model_class.model_fields or values_to_update.get(k) is not None:
+                continue
 
-    for key, value in config.items():
-        if key not in model_class.model_fields or values_to_update.get(key) is not None:
-            continue
-
-        if isinstance(value, dict) and isinstance(values_to_update.get(key), dict):
-            values_to_update[key].update(value)
-        else:
-            values_to_update[key] = value
+            if isinstance(v, dict) and isinstance(values_to_update.get(k), dict):
+                values_to_update[k].update(v)
+            else:
+                values_to_update[k] = v
 
     return values_to_update

versionhq/agent/TEMPLATES/Backstory.py

@@ -1,3 +1,4 @@
-BACKSTORY="""You are a {role} with deep understanding of {knowledge} and highly skilled in {skillsets}.
-You have access to call the RAG tools that can {rag_tool_overview}. By leveraging these tools, your knowledge, and skillsets, you can identify competitive strategies that have been proven effective to achieve the goal: {goal}. Take these into consideration, create innovative solutions.
-"""
+BACKSTORY_FULL="""You are an expert {role} with deep understanding of {knowledge} and highly skilled in {skillsets}. You have abilities to call the RAG tools that can {rag_tool_overview}. Your primary goal is to identify competitive solutions by leveraging your knowledge and skillsets to achieve the following goal: {goal}."""
+
+
+BACKSTORY_SHORT="""You are an expert {role} with the right skillsets and knowledge. Your primary goal is to identify competitive solutions by leveraging your knowledge and skillsets to achieve the following goal: {goal}."""

versionhq/agent/model.py

@@ -1,19 +1,20 @@
 import os
 import uuid
-from typing import Any, Dict, List, Optional, TypeVar
+from typing import Any, Dict, List, Optional, TypeVar, Callable, Type
 from typing_extensions import Self
 from dotenv import load_dotenv
-from pydantic import UUID4, BaseModel, Field, InstanceOf, PrivateAttr, model_validator, field_validator
+import litellm
+
+from pydantic import UUID4, BaseModel, Field, InstanceOf, PrivateAttr, model_validator, field_validator, ConfigDict
 from pydantic_core import PydanticCustomError
 
+from versionhq.llm.model import LLM, DEFAULT_CONTEXT_WINDOW_SIZE, DEFAULT_MODEL_NAME
+from versionhq.tool.model import Tool, ToolSet
 from versionhq._utils.logger import Logger
 from versionhq._utils.rpm_controller import RPMController
 from versionhq._utils.usage_metrics import UsageMetrics
-from versionhq.llm.llm_vars import LLM_VARS
-from versionhq.llm.model import LLM, DEFAULT_CONTEXT_WINDOW
-from versionhq.task import TaskOutputFormat
-from versionhq.task.model import ResponseField
-from versionhq.tool.model import Tool, ToolSet
+from versionhq._utils.process_config import process_config
+
 
 load_dotenv(override=True)
 T = TypeVar("T", bound="Agent")
@@ -87,48 +88,43 @@ class Agent(BaseModel):
     _request_within_rpm_limit: Any = PrivateAttr(default=None)
     _token_process: TokenProcess = PrivateAttr(default_factory=TokenProcess)
     _times_executed: int = PrivateAttr(default=0)
+    config: Optional[Dict[str, Any]] = Field(default=None, exclude=True, description="values to add to the Agent class")
 
     id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
     role: str = Field(description="role of the agent - used in summary and logs")
     goal: str = Field(description="concise goal of the agent (details are set in the Task instance)")
-    backstory: Optional[str] = Field(default=None, description="system context passed to the LLM")
+    backstory: Optional[str] = Field(default=None, description="developer prompt to the llm")
     knowledge: Optional[str] = Field(default=None, description="external knowledge fed to the agent")
     skillsets: Optional[List[str]] = Field(default_factory=list)
-    tools: Optional[List[Tool | Any]] = Field(default_factory=list)
+    tools: Optional[List[Tool | ToolSet | Type[Tool]]] = Field(default_factory=list)
 
-    # team, task execution rules
+    # prompting
+    use_developer_prompt: Optional[bool] = Field(default=True, description="Use developer prompt when calling the llm")
+    developer_propmt_template: Optional[str] = Field(default=None, description="ddeveloper prompt template")
+    user_prompt_template: Optional[str] = Field(default=None, description="user prompt template")
+
+    # task execution rules
     team: Optional[List[Any]] = Field(default=None, description="Team to which the agent belongs")
-    allow_delegation: bool = Field(default=False,description="Enable agent to delegate and ask questions among each other")
-    allow_code_execution: Optional[bool] = Field(default=False, description="Enable code execution for the agent.")
-    max_retry_limit: int = Field(default=2,description="max. number of retries for the task execution when an error occurs. cascaed to the `invoke` function")
-    max_iter: Optional[int] = Field(default=25,description="max. number of iterations for an agent to execute a task")
-    step_callback: Optional[Any] = Field(default=None,description="Callback to be executed after each step of the agent execution")
+    allow_delegation: bool = Field(default=False,description="if the agent can delegate the task to another agent or ask some help")
+    max_retry_limit: int = Field(default=2 ,description="max. number of retry for the task execution when an error occurs")
+    maxit: Optional[int] = Field(default=25,description="max. number of total optimization loops conducted when an error occurs")
+    callbacks: Optional[List[Callable]] = Field(default_factory=list, description="callback functions to execute after any task execution")
 
     # llm settings cascaded to the LLM model
-    llm: str | InstanceOf[LLM] | Any = Field(default=None)
-    function_calling_llm: str | InstanceOf[LLM] | Any = Field(default=None)
+    llm: str | InstanceOf[LLM] | Dict[str, Any] = Field(default=None)
+    function_calling_llm: str | InstanceOf[LLM] | Dict[str, Any] = Field(default=None)
     respect_context_window: bool = Field(default=True,description="Keep messages under the context window size by summarizing content")
     max_tokens: Optional[int] = Field(default=None, description="max. number of tokens for the agent's execution")
     max_execution_time: Optional[int] = Field(default=None, description="max. execution time for an agent to execute a task")
     max_rpm: Optional[int] = Field(default=None, description="max. number of requests per minute for the agent execution")
-
-    # prompt rules
-    use_system_prompt: Optional[bool] = Field(default=True, description="Use system prompt for the agent")
-    system_template: Optional[str] = Field(default=None, description="System format for the agent.")
-    prompt_template: Optional[str] = Field(default=None, description="Prompt format for the agent.")
-    response_template: Optional[str] = Field(default=None, description="Response format for the agent.")
+    llm_config: Optional[Dict[str, Any]] = Field(default=None, description="other llm config cascaded to the model")
 
     # config, cache, error handling
-    config: Optional[Dict[str, Any]] = Field(default=None, exclude=True, description="Configuration for the agent")
-    formatting_errors: int = Field(default=0, description="Number of formatting errors.")
+    formatting_errors: int = Field(default=0, description="number of formatting errors.")
     agent_ops_agent_name: str = None
     agent_ops_agent_id: str = None
 
 
-    def __repr__(self):
-        return f"Agent(role={self.role}, goal={self.goal}, backstory={self.backstory})"
-
-
     @field_validator("id", mode="before")
     @classmethod
     def _deny_user_set_id(cls, v: Optional[UUID4]) -> None:
@@ -136,12 +132,27 @@ class Agent(BaseModel):
             raise PydanticCustomError("may_not_set_field", "This field is not to be set by the user.", {})
 
 
+    # @field_validator(mode="before")
+    # def set_up_from_config(cls) -> None:
+    #     if cls.config is not None:
+    #         try:
+    #             for k, v in cls.config.items():
+    #                 setattr(cls, k, v)
+    #         except:
+    #             pass
+
+    @model_validator(mode="before")
+    @classmethod
+    def process_model_config(cls, values: Dict[str, Any]) -> None:
+        return process_config(values_to_update=values, model_class=cls)
+
+
     @model_validator(mode="after")
     def validate_required_fields(self) -> Self:
         required_fields = ["role", "goal"]
         for field in required_fields:
             if getattr(self, field) is None:
-                raise ValueError( f"{field} must be provided either directly or through config")
+                raise ValueError(f"{field} must be provided either directly or through config")
         return self
 
 
@@ -149,117 +160,120 @@ class Agent(BaseModel):
     def set_up_llm(self) -> Self:
         """
         Set up the base model and function calling model (if any) using the LLM class.
-        Pass the model config params: `llm`, `max_tokens`, `max_execution_time`, `step_callback`,`respect_context_window` to the LLM class.
+        Pass the model config params: `llm`, `max_tokens`, `max_execution_time`, `callbacks`,`respect_context_window` to the LLM class.
         The base model is selected on the client app, else use the default model.
         """
 
         self.agent_ops_agent_name = self.role
-        unaccepted_attributes = ["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY", "AWS_REGION_NAME"]
-        callbacks = ([self.step_callback,]if self.step_callback is not None else [])
+        # unaccepted_attributes = ["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY", "AWS_REGION_NAME"]
 
         if isinstance(self.llm, LLM):
-            self.llm.timeout = self.max_execution_time
-            self.llm.max_tokens = self.max_tokens
-            self.llm.context_window_size = (self.llm.get_context_window_size() if self.respect_context_window == True else DEFAULT_CONTEXT_WINDOW)
-            self.llm.callbacks = callbacks
+            llm = self._set_llm_params(self.llm)
+            self.llm = llm
 
         elif isinstance(self.llm, str) or self.llm is None:
-            model_name = os.environ.get("LITELLM_MODEL_NAME", os.environ.get("MODEL", "gpt-3.5-turbo"))
-            llm_params = {
-                "model": model_name if self.llm is None else self.llm,
-                "timeout": self.max_execution_time,
-                "max_tokens": self.max_tokens,
-                "callbacks": callbacks,
-                "api_key": os.environ.get("LITELLM_API_KEY", None),
-                "base_url": os.environ.get("OPENAI_API_BASE", os.environ.get("OPENAI_BASE_URL", None))
-            }
-
-            set_provider = model_name.split("/")[0] if "/" in model_name else "openai" #! REFINEME
-            for provider, env_vars in LLM_VARS.items():
-                if provider == set_provider:
-                    for env_var in env_vars:
-                        key_name = env_var.get("key_name")
-
-                        if key_name and key_name not in unaccepted_attributes:
-                            env_value = os.environ.get(key_name)
-                            if env_value:
-                                key_name = ("api_key" if "API_KEY" in key_name else key_name)
-                                key_name = ("api_base" if "API_BASE" in key_name else key_name)
-                                key_name = ("api_version" if "API_VERSION" in key_name else key_name)
-                                llm_params[key_name] = env_value
-                        elif env_var.get("default", False):
-                            for key, value in env_var.items():
-                                if key not in ["prompt", "key_name", "default"]:
-                                    if key in os.environ:
-                                        llm_params[key] = value
-            self.llm = LLM(**llm_params)
-            context_window_size = (self.llm.get_context_window_size() if self.respect_context_window == True else DEFAULT_CONTEXT_WINDOW)
-            self.llm.context_window_size = context_window_size
+            model_name = self.llm if self.llm is not None else DEFAULT_MODEL_NAME
+            llm = LLM(model=model_name)
+            updated_llm = self._set_llm_params(llm)
+            self.llm = updated_llm
 
         else:
-            llm_params = {
-                "model": (getattr(self.llm, "model_name") or getattr(self.llm, "deployment_name") or str(self.llm)),
-                "max_tokens": (getattr(self.llm, "max_tokens") or self.max_tokens or 3000),
-                "timeout": getattr(self.llm, "timeout", self.max_execution_time),
-                "callbacks": getattr(self.llm, "callbacks") or callbacks,
-                "temperature": getattr(self.llm, "temperature", None),
-                "logprobs": getattr(self.llm, "logprobs", None),
-                "api_key": getattr(self.llm, "api_key", os.environ.get("LITELLM_API_KEY", None)),
-                "base_url": getattr(self.llm, "base_url", None),
-                "organization": getattr(self.llm, "organization", None),
-            }
-            llm_params = {  k: v for k, v in llm_params.items() if v is not None }
-            self.llm = LLM(**llm_params)
+            if isinstance(self.llm, dict):
+                model_name = self.llm.pop("model_name", self.llm.pop("deployment_name", str(self.llm)))
+                llm = LLM(model=model_name if model_name is not None else DEFAULT_MODEL_NAME)
+                updated_llm = self._set_llm_params(llm, { k: v for k, v in self.llm.items() if v is not None })
+                self.llm = updated_llm
+
+            else:
+                model_name = (getattr(self.llm, "model_name") or getattr(self.llm, "deployment_name") or str(self.llm))
+                llm = LLM(model=model_name)
+                llm_params = {
+                    "max_tokens": (getattr(self.llm, "max_tokens") or self.max_tokens or 3000),
+                    "timeout": getattr(self.llm, "timeout", self.max_execution_time),
+                    "callbacks": getattr(self.llm, "callbacks", None),
+                    "temperature": getattr(self.llm, "temperature", None),
+                    "logprobs": getattr(self.llm, "logprobs", None),
+                    "api_key": getattr(self.llm, "api_key", os.environ.get("LITELLM_API_KEY", None)),
+                    "base_url": getattr(self.llm, "base_url", None),
+                }
+                updated_llm = self._set_llm_params(llm, llm_params)
+                self.llm = updated_llm
+
 
         """
-        Set up funcion_calling LLM as well. For the sake of convenience, use the same metrics as the base LLM settings.
+        Set up funcion_calling LLM as well.
+        Check if the model supports function calling, setup LLM instance accordingly, using the same params with the LLM.
         """
         if self.function_calling_llm:
             if isinstance(self.function_calling_llm, LLM):
-                self.function_calling_llm.timeout = self.max_execution_time
-                self.function_calling_llm.max_tokens = self.max_tokens
-                self.function_calling_llm.callbacks = callbacks
-                context_window_size = (
-                    self.function_calling_llm.get_context_window_size()
-                    if self.respect_context_window == True
-                    else DEFAULT_CONTEXT_WINDOW
-                )
-                self.function_calling_llm.context_window_size = context_window_size
+                if self.function_calling_llm._supports_function_calling() == False:
+                    self.function_calling_llm = LLM(model=DEFAULT_MODEL_NAME)
+
+                updated_llm = self._set_llm_params(self.function_calling_llm)
+                self.function_calling_llm = updated_llm
 
             elif isinstance(self.function_calling_llm, str):
-                self.function_calling_llm = LLM(
-                    model=self.function_calling_llm,
-                    timeout=self.max_execution_time,
-                    max_tokens=self.max_tokens,
-                    callbacks=callbacks,
-                )
-                context_window_size = (
-                    self.function_calling_llm.get_context_window_size()
-                    if self.respect_context_window == True
-                    else DEFAULT_CONTEXT_WINDOW
-                )
-                self.function_calling_llm.context_window_size = context_window_size
+                llm = LLM(model=self.function_calling_llm)
+
+                if llm._supports_function_calling() == False:
+                    llm = LLM(model=DEFAULT_MODEL_NAME)
+
+                updated_llm = self._set_llm_params(llm)
+                self.function_calling_llm = updated_llm
 
             else:
-                model_name = getattr(
-                    self.function_calling_llm,
-                    "model_name",
-                    getattr(
-                        self.function_calling_llm,
-                        "deployment_name",
-                        str(self.function_calling_llm),
-                    ),
-                )
-                if model_name is not None or model_name != "":
-                    self.function_calling_llm = LLM(
-                        model=model_name,
-                        timeout=self.max_execution_time,
-                        max_tokens=self.max_tokens,
-                        callbacks=callbacks,
-                    )
+                if isinstance(self.function_calling_llm, dict):
+                    model_name = self.function_calling_llm.pop("model_name", self.function_calling_llm.pop("deployment_name", str(self.function_calling_llm)))
+                    llm = LLM(model=model_name)
+                    updated_llm = self._set_llm_params(llm, { k: v for k, v in self.function_calling_llm.items() if v is not None })
+                    self.function_calling_llm = updated_llm
+
+                else:
+                    model_name = (getattr(self.function_calling_llm, "model_name") or getattr(self.function_calling_llm, "deployment_name") or str(self.function_calling_llm))
+                    llm = LLM(model=model_name)
+                    llm_params = {
+                        "max_tokens": (getattr(self.function_calling_llm, "max_tokens") or self.max_tokens or 3000),
+                        "timeout": getattr(self.function_calling_llm, "timeout", self.max_execution_time),
+                        "callbacks": getattr(self.function_calling_llm, "callbacks", None),
+                        "temperature": getattr(self.function_calling_llm, "temperature", None),
+                        "logprobs": getattr(self.function_calling_llm, "logprobs", None),
+                        "api_key": getattr(self.function_calling_llm, "api_key", os.environ.get("LITELLM_API_KEY", None)),
+                        "base_url": getattr(self.function_calling_llm, "base_url", None),
+                    }
+                    updated_llm = self._set_llm_params(llm, llm_params)
+                    self.function_calling_llm = updated_llm
+
         return self
 
 
+    def _set_llm_params(self, llm: LLM, config: Dict[str, Any] = None) -> LLM:
+        """
+        After setting up an LLM instance, add params to the instance.
+        Prioritize the agent's settings over the model's base setups.
+        """
+
+        llm.timeout = self.max_execution_time if llm.timeout is None else llm.timeout
+        llm.max_tokens = self.max_tokens if self.max_tokens else llm.max_tokens
+
+        # if self.callbacks:
+        #     llm.callbacks = self.callbacks
+        #     llm._set_callbacks(llm.callbacks)
+
+        if self.respect_context_window == False:
+            llm.context_window_size = DEFAULT_CONTEXT_WINDOW_SIZE
+
+        config = self.config.update(config) if self.config else config
+        if config:
+            valid_params = litellm.get_supported_openai_params(model=llm.model)
+            for k, v in config.items():
+                try:
+                    if k in valid_params and v is not None:
+                        setattr(llm, k, v)
+                except:
+                    pass
+        return llm
+
+
     @model_validator(mode="after")
     def set_up_tools(self) -> Self:
         """
@@ -270,25 +284,21 @@ class Agent(BaseModel):
 
         else:
             tool_list = []
-            def empty_func():
-                return "empty function"
 
             for item in self.tools:
                 if isinstance(item, Tool):
                     tool_list.append(item)
 
-                elif isinstance(item, dict):
-                    if "function" not in item:
-                       setattr(item, "function", empty_func)
+                elif isinstance(item, dict) and "func" in item:
                     tool = Tool(**item)
                     tool_list.append(tool)
 
-                elif isinstance(item, str):
-                    tool = Tool(name=item, function=empty_func)
-                    tool_list.append(tool)
+                elif type(item) is Tool and hasattr(item, "func"):
+                    tool_list.append(item)
 
                 else:
-                    tool_list.append(item) # address custom tool
+                    self._logger.log(level="error", message=f"Tool {str(item)} is missing a function.", color="red")
+                    raise PydanticCustomError("invalid_tool", f"The tool {str(item)} is missing a function.", {})
 
             self.tools = tool_list
 
@@ -302,92 +312,116 @@ class Agent(BaseModel):
         """
 
         if self.backstory is None:
-            from versionhq.agent.TEMPLATES.Backstory import BACKSTORY
-            backstory = BACKSTORY.format(
-                role=self.role,
-                knowledge=self.knowledge if isinstance(self.knowledge, str) else None,
-                skillsets=", ".join([item for item in self.skillsets]),
-                rag_tool_overview=", ".join([item.name for item in self.tools if hasattr(item, "name")]) if self.tools else "",
-                goal=self.goal,
-            )
+            from versionhq.agent.TEMPLATES.Backstory import BACKSTORY_FULL, BACKSTORY_SHORT
+            backstory = ""
+
+            if self.tools or self.knowledge or self.skillsets:
+                backstory = BACKSTORY_FULL.format(
+                    role=self.role,
+                    goal=self.goal,
+                    knowledge=self.knowledge if isinstance(self.knowledge, str) else None,
+                    skillsets=", ".join([item for item in self.skillsets]),
+                    rag_tool_overview=", ".join([item.name for item in self.tools if hasattr(item, "name")]) if self.tools else "",
+                )
+            else:
+                backstory = BACKSTORY_SHORT.format(role=self.role, goal=self.goal)
+
             self.backstory = backstory
 
         return self
 
 
-    def invoke(self, prompts: str, output_formats: List[TaskOutputFormat], response_fields: List[ResponseField], **kwargs) -> Dict[str, Any]:
+    def invoke(
+        self,
+        prompts: str,
+        response_format: Optional[Dict[str, Any]] = None,
+        tools: Optional[List[Tool | ToolSet | Type[Tool]]] = None,
+        tool_res_as_final: bool = False
+        ) -> Dict[str, Any]:
         """
-        Receive the system prompt in string and create formatted prompts using the system prompt and the agent's backstory.
-        Then call the base model.
-        When encountering errors, we try the task execution up to `self.max_retry_limit` times.
+        Create formatted prompts using the developer prompt and the agent's backstory, then call the base model.
+        - Execute the task up to `self.max_retry_limit` times in case of receiving an error or empty response.
+        - Pass the task_tools to the model to let them execute.
         """
 
-        task_execution_counter, raw_response = 0, None
-
+        task_execution_counter = 0
+        iterations = 0
+        raw_response = None
         messages = []
-        messages.append({"role": "user", "content": prompts})  #! REFINEME
-        messages.append({"role": "assistant", "content": self.backstory})
+
+        messages.append({"role": "user", "content": prompts})
+        if self.use_developer_prompt:
+            messages.append({"role": "system", "content": self.backstory})
         self._logger.log(level="info", message=f"Messages sent to the model: {messages}", color="blue")
 
-        callbacks = kwargs.get("callbacks", None)
+        try:
+            if tool_res_as_final is True:
+                func_llm = self.function_calling_llm if self.function_calling_llm and self.function_calling_llm._supports_function_calling() else LLM(model=DEFAULT_MODEL_NAME)
+                raw_response = func_llm.call(messages=messages, tools=tools, tool_res_as_final=True)
+            else:
+                raw_response = self.llm.call(messages=messages, response_format=response_format, tools=tools)
+
+            task_execution_counter += 1
+            self._logger.log(level="info", message=f"Agent response: {raw_response}", color="blue")
+
+            if raw_response and self.callbacks:
+                for item in self.callbacks:
+                    raw_response = item(raw_response)
+
+        except Exception as e:
+            self._logger.log(level="error", message=f"An error occured. The agent will retry: {str(e)}", color="red")
+
+            while not raw_response and task_execution_counter < self.max_retry_limit:
+                while not raw_response and iterations < self.maxit:
+                    raw_response = self.llm.call(messages=messages, response_format=response_format, tools=tools)
+                    iterations += 1
 
-        raw_response = self.llm.call(
-            messages=messages, output_formats=output_formats, field_list=response_fields, callbacks=callbacks
-        )
-        task_execution_counter += 1
-        self._logger.log(level="info", message=f"Agent's first response in {type(raw_response).__name__}: {raw_response}", color="blue")
-
-        if (raw_response is None or raw_response == "") and task_execution_counter < self.max_retry_limit:
-            while task_execution_counter <= self.max_retry_limit:
-                raw_response = self.llm.call(
-                    messages=messages,
-                    output_formats=output_formats,
-                    field_list=response_fields,
-                    callbacks=callbacks,
-                )
                 task_execution_counter += 1
-                self._logger.log(level="info", message=f"Agent's next response in {type(raw_response).__name__}: {raw_response}", color="blue")
+                self._logger.log(level="info", message=f"Agent #{task_execution_counter} response: {raw_response}", color="blue")
 
-        elif raw_response is None or raw_response == "":
-            self._logger.log(level="error", message="Received None or empty response from the model", color="red")
-            raise ValueError("Invalid response from LLM call - None or empty.")
+                if raw_response and self.callbacks:
+                    for item in self.callbacks:
+                        raw_response = item(raw_response)
+
+            if not raw_response:
+                self._logger.log(level="error", message="Received None or empty response from the model", color="red")
+                raise ValueError("Invalid response from LLM call - None or empty.")
 
         return raw_response
 
 
-    def execute_task(self, task, context: Optional[str] = None) -> str:
+    def execute_task(self, task, context: Optional[str] = None, task_tools: Optional[List[Tool | ToolSet]] = None) -> str:
         """
         Execute the task and return the response in string.
         The agent utilizes the tools in task or their own tools if the task.can_use_agent_tools is True.
         The agent must consider the context to excute the task as well when it is given.
         """
+        from versionhq.task.model import Task
 
-        task_prompt = task.prompt()
-        if context is not task.prompt_context:  # as `task.prompt()` includes adding `task.prompt_context` to the prompt.
-            task_prompt += context
-
-        tool_results = []
-        if task.tools:
-            for item in task.tools:
-                if isinstance(item, ToolSet):
-                    tool_result = item.tool.run(**item.kwargs)
-                    tool_results.append(tool_result)
-                elif isinstance(item, Tool):
-                    tool_result = item.run()
-                    tool_results.append(tool_result)
-                else:
-                    try:
-                        item.run()
-                    except:
-                        pass
+        task: InstanceOf[Task] = task
+        tools: Optional[List[Tool | ToolSet | Type[Tool]]] = task_tools + self.tools if task.can_use_agent_tools else task_tools
 
-        if task.can_use_agent_tools is True and self.tools:
-            for tool in self.tools:
-                tool_result = tool.run()
-                tool_results.append(tool_result)
+        task_prompt = task.prompt(model_provider=self.llm.provider)
+        if context is not task.prompt_context:
+            task_prompt += context
 
-        if task.take_tool_res_as_final:
-            return tool_results
+            # if agent_tools_to_run_without_llm:
+            #     tool_results = []
+            #     for item in agent_tools_to_run_without_llm:
+            #         if isinstance(item, ToolSet):
+            #             tool_result = item.tool.run(**item.kwargs)
+            #             tool_results.append(tool_result)
+            #         elif isinstance(item, Tool):
+            #             tool_result = item.run()
+            #             tool_results.append(tool_result)
+            #         else:
+            #             try:
+            #                 item.run()
+            #             except:
+            #                 pass
+
+            #     if task.tool_res_as_final is True:
+            #         return tool_results
 
         # if self.team and self.team._train:
         #     task_prompt = self._training_handler(task_prompt=task_prompt)
@@ -395,19 +429,28 @@ class Agent(BaseModel):
         #     task_prompt = self._use_trained_data(task_prompt=task_prompt)
 
         try:
+            self._times_executed += 1
             raw_response = self.invoke(
                 prompts=task_prompt,
-                output_formats=task.expected_output_formats,
-                response_fields=task.output_field_list,
+                response_format=task._structure_response_format(model_provider=self.llm.provider),
+                tools=tools,
+                tool_res_as_final=task.tool_res_as_final,
             )
 
         except Exception as e:
             self._times_executed += 1
+            self._logger.log(level="error", message=f"The agent failed to execute the task. Error: {str(e)}", color="red")
+            raw_response = self.execute_task(task, context, task_tools)
+
             if self._times_executed > self.max_retry_limit:
+                self._logger.log(level="error", message=f"Max retry limit has exceeded.", color="red")
                 raise e
-            raw_response = self.execute_task(task, context)
 
         if self.max_rpm and self._rpm_controller:
             self._rpm_controller.stop_rpm_counter()
 
         return raw_response
+
+
+    def __repr__(self):
+        return f"Agent(role={self.role}, goal={self.goal}, backstory={self.backstory})"