versionhq 1.1.9.14__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.14"
+__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, Callable
+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_variables import LLM_VARS
-from versionhq.llm.model import LLM, DEFAULT_CONTEXT_WINDOW_SIZE, DEFAULT_MODEL_NAME
-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")
@@ -92,18 +93,22 @@ class Agent(BaseModel):
     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[Callable | 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] | Dict[str, Any] = Field(default=None)
@@ -112,15 +117,10 @@ class Agent(BaseModel):
     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
-    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
 
@@ -132,6 +132,21 @@ 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"]
@@ -145,7 +160,7 @@ 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.
         """
 
@@ -231,6 +246,34 @@ class Agent(BaseModel):
         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:
         """
@@ -241,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
 
@@ -273,108 +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 _set_llm_params(self, llm: LLM, kwargs: Dict[str, Any] = None) -> LLM:
+    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]:
         """
-        After setting up an LLM instance, add params to the instance.
-        Prioritize the agent's settings over the model's base setups.
+        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.
         """
 
-        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.step_callback is not None:
-            llm.callbacks = [self.step_callback, ]
-            llm._set_callbacks(llm.callbacks)
-
-        if self.respect_context_window == False:
-            llm.context_window_size = DEFAULT_CONTEXT_WINDOW_SIZE
+        task_execution_counter = 0
+        iterations = 0
+        raw_response = None
+        messages = []
 
-        if kwargs:
-            for k, v in kwargs.items():
-                try:
-                    setattr(llm, k, v)
-                except:
-                    pass
-        return llm
+        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")
 
+        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)
 
-    def invoke(self, prompts: str, output_formats: List[str | TaskOutputFormat], response_fields: List[ResponseField]) -> 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.
-        """
+            task_execution_counter += 1
+            self._logger.log(level="info", message=f"Agent response: {raw_response}", color="blue")
 
-        task_execution_counter, raw_response = 0, None
+            if raw_response and self.callbacks:
+                for item in self.callbacks:
+                    raw_response = item(raw_response)
 
-        messages = []
-        messages.append({"role": "user", "content": prompts})  #! REFINEME
-        messages.append({"role": "assistant", "content": self.backstory})
-        self._logger.log(level="info", message=f"Messages sent to the model: {messages}", color="blue")
+        except Exception as e:
+            self._logger.log(level="error", message=f"An error occured. The agent will retry: {str(e)}", color="red")
 
-        raw_response = self.llm.call(messages=messages, output_formats=output_formats, field_list=response_fields)
-        task_execution_counter += 1
-        self._logger.log(level="info", message=f"Agent's first response in {type(raw_response).__name__}: {raw_response}", color="blue")
+            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
 
-        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)
                 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)
@@ -382,17 +429,22 @@ 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()

versionhq/clients/product/model.py

@@ -5,7 +5,7 @@ from typing import Any, Dict, List, Callable, Type, Optional, get_args, get_orig
 from pydantic import UUID4, InstanceOf, BaseModel, ConfigDict, Field, create_model, field_validator, model_validator
 from pydantic_core import PydanticCustomError
 
-from versionhq.tool import ComposioAppName
+from versionhq.tool.composio_tool_vars import ComposioAppName
 
 
 class ProductProvider(ABC, BaseModel):

versionhq/clients/workflow/model.py

@@ -10,7 +10,7 @@ from versionhq.clients.product.model import Product
 from versionhq.clients.customer.model import Customer
 from versionhq.agent.model import Agent
 from versionhq.team.model import Team
-from versionhq.tool import ComposioAppName
+from versionhq.tool.composio_tool_vars import ComposioAppName
 
 
 class ScoreFormat: