versionhq 1.2.4.1__py3-none-any.whl → 1.2.4.3__py3-none-any.whl

versionhq/agent/model.py

@@ -10,9 +10,8 @@ from pydantic_core import PydanticCustomError
 from versionhq.agent.rpm_controller import RPMController
 from versionhq.tool.model import Tool, ToolSet, BaseTool
 from versionhq.knowledge.model import BaseKnowledgeSource, Knowledge
-from versionhq.memory.contextual_memory import ContextualMemory
 from versionhq.memory.model import ShortTermMemory, LongTermMemory, UserMemory
-from versionhq._utils import Logger, process_config, is_valid_url
+from versionhq._utils import Logger, process_config, is_valid_url, ErrorType
 
 
 load_dotenv(override=True)
@@ -32,6 +31,7 @@ class Agent(BaseModel):
     _logger_config: Dict[str, Any] = PrivateAttr(default=dict(verbose=True, info_file_save=True))
 
     api_key: Optional[str] = Field(default=None)
+    self_learn: bool = Field(default=False)
     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)
@@ -337,25 +337,6 @@ class Agent(BaseModel):
         return llm
 
 
-    def _update_llm(self, llm: Any = None, llm_config: Optional[Dict[str, Any]] = None) -> Self:
-        """
-        Update llm and llm_config of the exsiting agent. (Other conditions will remain the same.)
-        """
-
-        if not llm and not llm_config:
-            Logger(**self._logger_config, filename=self.key).log(level="error", message="Missing llm or llm_config values to update", color="red")
-            pass
-
-        self.llm = llm
-        if llm_config:
-            if self.llm_config:
-                self.llm_config.update(llm_config)
-            else:
-                self.llm_config = llm_config
-
-        return self.set_up_llm()
-
-
     def _train(self) -> Self:
         """
         Fine-tuned the base model using OpenAI train framework.
@@ -392,16 +373,17 @@ class Agent(BaseModel):
 
             if tool_res_as_final:
                 raw_response = self.func_calling_llm.call(messages=messages, tools=tools, tool_res_as_final=True)
-                task._tokens = self.func_calling_llm._tokens
+                task._usage.record_token_usage(token_usages=self.func_calling_llm._usages)
             else:
                 raw_response = self.llm.call(messages=messages, response_format=response_format, tools=tools)
-                task._tokens = self.llm._tokens
+                task._usage.record_token_usage(token_usages=self.llm._usages)
 
             task_execution_counter += 1
             Logger(**self._logger_config, filename=self.key).log(level="info", message=f"Agent response: {raw_response}", color="green")
             return raw_response
 
         except Exception as e:
+            task._usage.record_errors(type=ErrorType.API)
             Logger(**self._logger_config, filename=self.key).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:
@@ -422,6 +404,25 @@ class Agent(BaseModel):
                 raise ValueError("Invalid response from LLM call - None or empty.")
 
 
+    def _update_llm(self, llm: Any = None, llm_config: Optional[Dict[str, Any]] = None) -> Self:
+        """
+        Updates llm and llm_config of the exsiting agent. (Other conditions will remain the same.)
+        """
+
+        if not llm and not llm_config:
+            Logger(**self._logger_config, filename=self.key).log(level="error", message="Missing llm or llm_config values to update", color="red")
+            pass
+
+        self.llm = llm
+        if llm_config:
+            if self.llm_config:
+                self.llm_config.update(llm_config)
+            else:
+                self.llm_config = llm_config
+
+        return self.set_up_llm()
+
+
     def update(self, **kwargs) -> Self:
         """
         Update the existing agent. Address variables that require runnning set_up_x methods first, then update remaining variables.
@@ -501,13 +502,11 @@ class Agent(BaseModel):
 
 
     def execute_task(self, task, context: Optional[Any] = None, task_tools: Optional[List[Tool | ToolSet]] = list()) -> str:
-        """
-        Format a task prompt, adding context from knowledge and memory (if given), and invoke LLM.
-        """
+        """Handling task execution."""
 
         from versionhq.task.model import Task
         from versionhq.tool.rag_tool import RagTool
-        from versionhq.knowledge._utils import extract_knowledge_context
+        from versionhq._prompt.model import Prompt
 
         task: InstanceOf[Task] = task
         all_tools: Optional[List[Tool | ToolSet | RagTool | Type[BaseTool]]] = task_tools + self.tools if task.can_use_agent_tools else task_tools
@@ -517,57 +516,7 @@ class Agent(BaseModel):
         if self.max_rpm and self._rpm_controller:
             self._rpm_controller._reset_request_count()
 
-        user_prompt = task._user_prompt(model_provider=self.llm.provider, context=context)
-
-        if self._knowledge:
-            agent_knowledge = self._knowledge.query(query=[user_prompt,], limit=5)
-            if agent_knowledge:
-                agent_knowledge_context = extract_knowledge_context(knowledge_snippets=agent_knowledge)
-                if agent_knowledge_context:
-                    user_prompt += agent_knowledge_context
-
-        if rag_tools:
-            for item in rag_tools:
-                rag_tool_context = item.run(agent=self, query=task.description)
-                if rag_tool_context:
-                    user_prompt += ",".join(rag_tool_context) if isinstance(rag_tool_context, list) else str(rag_tool_context)
-
-        if self.with_memory == True:
-            contextual_memory = ContextualMemory(
-                memory_config=self.memory_config, stm=self.short_term_memory, ltm=self.long_term_memory, um=self.user_memory
-            )
-            context_str = task._draft_context_prompt(context=context)
-            query = f"{task.description} {context_str}".strip()
-            memory = contextual_memory.build_context_for_task(query=query)
-            if memory.strip() != "":
-                user_prompt += memory.strip()
-
-        ## comment out for now
-        # if self.networks and self.networks._train:
-        #     user_prompt = self._training_handler(user_prompt=user_prompt)
-        # else:
-        #     user_prompt = self._use_trained_data(user_prompt=user_prompt)
-
-        content_prompt = task._format_content_prompt()
-
-        messages = []
-        if content_prompt:
-            messages.append(
-                {
-                    "role": "user",
-                    "content": [
-                        {
-                            "type": "text",
-                            "text": user_prompt
-                        },
-                        content_prompt,
-                    ]
-                })
-        else:
-            messages.append({ "role": "user", "content": user_prompt })
-
-        if self.use_developer_prompt:
-            messages.append({ "role": "developer", "content": self.backstory })
+        user_prompt, dev_prompt, messages = Prompt(task=task, agent=self, context=context).format_core(rag_tools=rag_tools)
 
         try:
             self._times_executed += 1
@@ -578,11 +527,13 @@ class Agent(BaseModel):
                 tool_res_as_final=task.tool_res_as_final,
                 task=task
             )
+            if raw_response:
+                task._usage.successful_requests += 1
 
         except Exception as e:
             self._times_executed += 1
             Logger(**self._logger_config, filename=self.key).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)
+            user_prompt, dev_prompt, raw_response = self.execute_task(task, context, task_tools)
 
             if self._times_executed > self.max_retry_limit:
                 Logger(**self._logger_config, filename=self.key).log(level="error", message=f"Max retry limit has exceeded.", color="red")
@@ -591,7 +542,7 @@ class Agent(BaseModel):
         if self.max_rpm and self._rpm_controller:
             self._rpm_controller.stop_rpm_counter()
 
-        return raw_response
+        return user_prompt, dev_prompt, raw_response
 
 
     @property

versionhq/agent_network/formation.py

@@ -93,10 +93,11 @@ def form_agent_network(
 
     network_tasks = []
     members = []
-    leader = str(res.pydantic.leader_agent) if res.pydantic else str(res.json_dict["leader_agent"])
-
-    agent_roles = res.pydantic.agent_roles if res.pydantic else res.json_dict["agent_roles"]
-    created_agents = [Agent(role=str(item), goal=str(item)) for item in agent_roles]
+    leader = res._fetch_value_of(key="leader_agent")
+    agent_roles =  res._fetch_value_of(key="agent_roles")
+    created_agents = [Agent(role=str(item), goal=str(item)) for item in agent_roles] if agent_roles else []
+    task_descriptions = res._fetch_value_of(key="task_descriptions")
+    task_outcomes = res._fetch_value_of(key="task_outcomes")
 
     if agents:
         for i, agent in enumerate(created_agents):
@@ -108,9 +109,9 @@ def form_agent_network(
 
     created_tasks = []
 
-    if res.pydantic:
-        for i, item in enumerate(res.pydantic.task_outcomes):
-            if len(res.pydantic.task_descriptions) > i and res.pydantic.task_descriptions[i]:
+    if task_outcomes:
+        for i, item in enumerate(task_outcomes):
+            if len(task_descriptions) > i and task_descriptions[i]:
                 fields = {}
                 for ob in item:
                     try:
@@ -119,33 +120,18 @@ def form_agent_network(
                     except:
                         pass
                 output = create_model("Output", **fields) if fields else None
-                _task = Task(description=res.pydantic.task_descriptions[i], pydantic_output=output)
+                _task = Task(description=task_descriptions[i], pydantic_output=output)
                 created_tasks.append(_task)
 
-    elif res.json_dict:
-        for i, item in enumerate(res["task_outcomes"]):
-            if len(res["task_descriptions"]) > i and res["task_descriptions"][i]:
-                fields = {}
-                for ob in item:
-                    try:
-                        field_name = str(ob).lower().split(":")[0].replace(" ", "_")[0: 16]
-                        fields[field_name] = (str, Field(default=None))
-                    except:
-                        pass
-                output = create_model("Output", **fields) if fields else None
-                _task = Task(description=res["task_descriptions"][i], pydantic_output=output)
-                created_tasks.append(_task)
-
-
     if len(created_tasks) <= len(created_agents):
         for i in range(len(created_tasks)):
-            is_manager = bool(created_agents[i].role.lower() == leader.lower())
+            is_manager = False if not leader else bool(created_agents[i].role.lower() == leader.lower())
             member = Member(agent=created_agents[i], is_manager=is_manager, tasks=[created_tasks[i]])
             members.append(member)
 
         for i in range(len(created_tasks), len(created_agents)):
             try:
-                is_manager = bool(created_agents[i].role.lower() == leader.lower())
+                is_manager = False if not leader else bool(created_agents[i].role.lower() == leader.lower())
                 member_w_o_task = Member(agent=created_agents[i], is_manager=is_manager)
                 members.append(member_w_o_task)
             except:
@@ -153,15 +139,15 @@ def form_agent_network(
 
     elif len(created_tasks) > len(created_agents):
         for i in range(len(created_agents)):
-            is_manager = bool(created_agents[i].role.lower() == leader.lower())
+            is_manager = False if not leader else bool(created_agents[i].role.lower() == leader.lower())
             member = Member(agent=created_agents[i], is_manager=is_manager, tasks=[created_tasks[i]])
             members.append(member)
 
         network_tasks.extend(created_tasks[len(created_agents):len(created_tasks)])
 
-
     if _formation == Formation.SUPERVISING and not [member for member in members if member.is_manager]:
-        manager = Member(agent=Agent(role=leader, goal=leader), is_manager=True)
+        role = leader if leader else "Leader"
+        manager = Member(agent=Agent(role=role), is_manager=True)
         members.append(manager)
 
     members.sort(key=lambda x: x.is_manager == False)

versionhq/agent_network/model.py

@@ -90,7 +90,6 @@ class AgentNetwork(BaseModel):
 
     cache: bool = Field(default=True)
     execution_logs: List[Dict[str, Any]] = Field(default_factory=list, description="list of execution logs of the tasks handled by members")
-    # usage_metrics: Optional[UsageMetrics] = Field(default=None, description="usage metrics for all the llm executions")
 
 
     def __name__(self) -> str:

versionhq/llm/model.py

@@ -69,7 +69,7 @@ class LLM(BaseModel):
 
     _logger: Logger = PrivateAttr(default_factory=lambda: Logger(verbose=True))
     _init_model_name: str = PrivateAttr(default=None)
-    _tokens: int = PrivateAttr(default=0) # aggregate number of tokens consumed
+    _usages: list[Dict[str, int]] = PrivateAttr(default_factory=list)
 
     model: str = Field(default=None)
     provider: Optional[str] = Field(default=None, description="model provider")
@@ -181,8 +181,6 @@ class LLM(BaseModel):
         """
         litellm.drop_params = True
 
-        self._tokens = 0
-
         if self.callbacks:
             self._set_callbacks(self.callbacks)
 
@@ -319,7 +317,7 @@ class LLM(BaseModel):
                 if not tools:
                     params = self._create_valid_params(config=config)
                     res = litellm.completion(model=self.model, messages=messages, stream=False, **params, **cred)
-                    self._tokens += int(res["usage"]["total_tokens"])
+                    self._usages.append(res["usage"])
                     return res["choices"][0]["message"]["content"]
 
                 else:
@@ -384,12 +382,11 @@ class LLM(BaseModel):
                         else:
                             pass
 
-
                 if tool_res_as_final:
                     return tool_res
                 else:
                     res = litellm.completion(model=self.model, messages=messages, **params, **cred)
-                    self._tokens += int(res["usage"]["total_tokens"])
+                    self._usages.append(res["usage"])
                     return res.choices[0].message.content
 
 

versionhq/storage/task_output_storage.py

@@ -147,8 +147,8 @@ class TaskOutputStorageHandler:
             description=str(task.description),
             raw=str(task.output.raw),
             responsible_agents=str(task.processed_agents),
-            tokens=task.output._tokens,
-            latency=task.output.latency,
+            tokens=task._usage.total_tokens,
+            latency=task._usage.latency,
             score=task.output.aggregate_score if task.output.aggregate_score else "None",
         )
         self.storage.add(task=task, output=output_to_store, inputs=inputs)