versionhq 1.1.12.4__py3-none-any.whl → 1.1.13.0__py3-none-any.whl

versionhq/__init__.py

@@ -4,6 +4,9 @@ warnings.filterwarnings(action="ignore", message="Pydantic serializer warnings:"
 warnings.filterwarnings(action="ignore", category=UserWarning, module="pydantic._internal")
 warnings.filterwarnings(action="ignore", module="LiteLLM:utils")
 
+from dotenv import load_dotenv
+load_dotenv(override=True)
+
 from versionhq.agent.model import Agent
 from versionhq.clients.customer.model import Customer
 from versionhq.clients.product.model import Product, ProductProvider
@@ -13,7 +16,7 @@ from versionhq.knowledge.source import PDFKnowledgeSource, CSVKnowledgeSource, J
 from versionhq.knowledge.source_docling import DoclingSource
 from versionhq.task.model import Task, TaskOutput, ConditionalTask, ResponseField
 from versionhq.task.evaluate import Evaluation, EvaluationItem
-from versionhq.team.model import Team, TeamOutput, Formation, TeamMember, TaskHandlingProcess
+from versionhq.team.model import Team, TeamOutput, Formation, Member, TaskHandlingProcess
 from versionhq.tool.model import Tool, ToolSet
 from versionhq.tool.cache_handler import CacheHandler
 from versionhq.tool.tool_handler import ToolHandler
@@ -24,7 +27,7 @@ from versionhq.memory.model import ShortTermMemory,LongTermMemory, UserMemory, M
 from versionhq.task.formation import form_agent_network
 
 
-__version__ = "1.1.12.4"
+__version__ = "1.1.13.0"
 __all__ = [
     "Agent",
 
@@ -55,7 +58,7 @@ __all__ = [
     "Team",
     "TeamOutput",
     "Formation",
-    "TeamMember",
+    "Member",
     "TaskHandlingProcess",
 
     "Tool",

versionhq/_utils/usage_metrics.py

@@ -3,14 +3,14 @@ from pydantic import BaseModel, Field
 
 class UsageMetrics(BaseModel):
     """
-    Model to track usage metrics for the agent/team's execution.
+    Model to track usage
     """
 
-    total_tokens: int = Field(default=0, description="Total number of tokens used")
-    prompt_tokens: int = Field(default=0, description="Number of tokens used in prompts")
-    cached_prompt_tokens: int = Field(default=0, description="Number of cached prompt tokens used")
-    completion_tokens: int = Field(default=0, description="Number of tokens used in completions")
-    successful_requests: int = Field(default=0, description="Number of successful requests made")
+    total_tokens: int = Field(default=0, description="total number of tokens used")
+    prompt_tokens: int = Field(default=0, description="number of tokens used in prompts")
+    cached_prompt_tokens: int = Field(default=0, description="number of cached prompt tokens used")
+    completion_tokens: int = Field(default=0, description="number of tokens used in completions")
+    successful_requests: int = Field(default=0, description="number of successful requests made")
 
     def add_usage_metrics(self, usage_metrics: "UsageMetrics") -> None:
         """

versionhq/agent/inhouse_agents.py

@@ -29,7 +29,7 @@ vhq_formation_planner = Agent(
     role="vhq-Formation Planner",
     goal="Plan a formation of agents based on the given task descirption.",
     llm="gemini/gemini-2.0-flash-exp",
-    llm_config=dict(top_p=0.8, top_k=30, temperature=0.9),
+    llm_config=dict(top_p=0.8, topK=40, temperature=0.9),
     maxit=1,
     max_retry_limit=1,
     knowledge_sources=[

versionhq/agent/model.py

@@ -274,7 +274,7 @@ class Agent(BaseModel):
             tool_list = []
 
             for item in self.tools:
-                if isinstance(item, Tool):
+                if isinstance(item, Tool) or isinstance(item, ToolSet):
                     tool_list.append(item)
 
                 elif isinstance(item, dict) and "func" in item:

versionhq/llm/llm_vars.py

@@ -55,6 +55,11 @@ MODELS = {
     "openrouter": [
         "openrouter/deepseek/deepseek-r1",
         "openrouter/qwen/qwen-2.5-72b-instruct",
+        "openrouter/google/gemini-2.0-flash-thinking-exp:free",
+        "openrouter/google/gemini-2.0-flash-thinking-exp-1219:free",
+        "openrouter/google/gemini-2.0-flash-001",
+        "openrouter/meta-llama/llama-3.3-70b-instruct",
+        "openrouter/mistralai/mistral-large-2411",
     ],
     "huggingface": [
         "huggingface/qwen/qwen2.5-VL-72B-Instruct",

versionhq/llm/model.py

@@ -100,7 +100,7 @@ class LLM(BaseModel):
     # LiteLLM specific fields
     api_base: Optional[str] = Field(default=None, description="litellm specific field - api base of the model provider")
     api_version: Optional[str] = Field(default=None)
-    num_retries: Optional[int] = Field(default=2)
+    num_retries: Optional[int] = Field(default=1)
     context_window_fallback_dict: Optional[Dict[str, Any]] = Field(default=None, description="A mapping of model to use if call fails due to context window error")
     fallbacks: Optional[List[Any]]= Field(default=None, description="A list of model names + params to be used, in case the initial call fails")
     metadata: Optional[Dict[str, Any]] = Field(default=None)
@@ -256,60 +256,86 @@ class LLM(BaseModel):
                 self._set_callbacks(self.callbacks) # passed by agent
 
             try:
-                self.response_format = { "type": "json_object" } if tool_res_as_final == True else response_format
+                res, tool_res = None, ""
 
                 if not tools:
+                    self.response_format = response_format
                     params = self._create_valid_params(config=config)
                     res = litellm.completion(model=self.model, messages=messages, stream=False, **params)
                     self._tokens += int(res["usage"]["total_tokens"])
                     return res["choices"][0]["message"]["content"]
 
                 else:
-                    self.tools = [item.tool.properties if isinstance(item, ToolSet) else item.properties for item in tools]
-                    params = self._create_valid_params(config=config)
-                    res = litellm.completion(model=self.model, messages=messages, **params)
-                    tool_calls = res.choices[0].message.tool_calls
-                    tool_res = ""
-
-                    for item in tool_calls:
-                        func_name = item.function.name
-                        func_args = item.function.arguments
-
-                        if not isinstance(func_args, dict):
-                            try:
-                                func_args = json.loads(json.dumps(eval(str(func_args))))
-                            except:
-                                pass
-
-                        for tool in tools:
-                            if isinstance(tool, ToolSet) and (tool.tool.name == func_name or tool.tool.func.__name__ == func_name or func_name == "random_func"):
-                                tool_instance = tool.tool
-                                args = tool.kwargs
-                                tool_res_to_add = tool_instance.run(params=args)
-
-                                if tool_res_as_final:
-                                    tool_res += str(tool_res_to_add)
-                                else:
-                                    messages.append(res.choices[0].message)
-                                    messages.append({ "role": "tool", "tool_call_id": item.id, "content": str(tool_res_to_add) })
+                    try:
+                        self.response_format = { "type": "json_object" }  if tool_res_as_final and self.provider != "gemini" else response_format
+                        self.tools = [item.tool.properties if isinstance(item, ToolSet) else item.properties for item in tools]
+                        params = self._create_valid_params(config=config)
+                        res = litellm.completion(model=self.model, messages=messages, **params)
+                        tool_calls = res.choices[0].message.tool_calls
+
+                        if tool_calls:
+                            for item in tool_calls:
+                                func_name = item.function.name
+                                func_args = item.function.arguments
+                                if not isinstance(func_args, dict):
+                                    try:
+                                        func_args = json.loads(json.dumps(eval(str(func_args))))
+                                    except:
+                                        pass
+
+                                # find a tool whose name is matched with the retrieved func_name
+                                matches = []
+                                for tool in tools:
+                                    tool_name = tool.tool.name if isinstance(tool, ToolSet) else tool.name
+                                    tool_func_name = tool.tool.func.__name__ if isinstance(tool, ToolSet) else tool.func.__name__
+                                    if tool_name.replace(" ", "_") == func_name or tool_func_name == func_name or tool_name == "random_func":
+                                        matches.append(tool)
+                                    else:
+                                        pass
+
+                                if matches:
+                                    tool_to_execute = matches[0]
+                                    tool_instance = tool_to_execute.tool if isinstance(tool_to_execute, ToolSet) else tool_to_execute
+                                    params = tool_to_execute.kwargs if isinstance(tool_to_execute, ToolSet) else func_args
+                                    tool_res_to_add = tool_instance.run(params=params) if params else tool_instance.run()
 
-                            else:
-                                try:
-                                    tool_res_to_add = tool.run(params=func_args)
                                     if tool_res_as_final:
-                                        tool_res += str(tool_res_to_add)
+                                        if tool_res_to_add not in tool_res:
+                                            tool_res += str(tool_res_to_add)
                                     else:
                                         messages.append(res.choices[0].message)
                                         messages.append({ "role": "tool", "tool_call_id": item.id, "content": str(tool_res_to_add) })
-                                except:
+
+                        else:
+                            if tool_res_as_final and tools and not tool_res:
+                                for item in tools:
+                                    tool_res_to_add = item.tool.run(params=item.kwargs) if isinstance(item, ToolSet) else item.run()
+                                    if tool_res_to_add not in tool_res:
+                                        tool_res += str(tool_res_to_add)
+                                    else:
+                                        pass
+
+                    except:
+                        if tool_res_as_final and tools and not tool_res:
+                            for item in tools:
+                                tool_res_to_add = item.tool.run(params=item.kwargs) if isinstance(item, ToolSet) else item.run()
+                                if tool_res_to_add not in tool_res:
+                                    tool_res += str(tool_res_to_add)
+                                else:
                                     pass
+                        elif tools and not tool_res:
+                                tool_res = res["choices"][0]["message"]["content"]
+                        else:
+                            pass
+
+
+                if tool_res_as_final:
+                    return tool_res
+                else:
+                    res = litellm.completion(model=self.model, messages=messages, **params)
+                    self._tokens += int(res["usage"]["total_tokens"])
+                    return res.choices[0].message.content
 
-                    if tool_res_as_final:
-                        return tool_res
-                    else:
-                        res = litellm.completion(model=self.model, messages=messages, **params)
-                        self._tokens += int(res["usage"]["total_tokens"])
-                        return res.choices[0].message.content
 
             except JSONSchemaValidationError as e:
                 self._logger.log(level="error", message="Raw Response: {}".format(e.raw_response), color="red")

versionhq/task/evaluate.py

@@ -70,17 +70,16 @@ class EvaluationItem(BaseModel):
         else: return None
 
 
-
 class Evaluation(BaseModel):
     items: List[EvaluationItem] = []
-    latency: int = Field(default=None, description="seconds")
+    latency: int = Field(default=None, description="job execution latency in seconds")
     tokens: int = Field(default=None, description="tokens consumed")
-    responsible_agent: Any = Field(default=None, description="store agent instance that evaluates the outcome")
+    eval_by: Any = Field(default=None, description="stores agent object that evaluates the outcome")
 
     @model_validator(mode="after")
-    def set_up_responsible_agent(self) -> Self:
+    def set_up_evaluator(self) -> Self:
         from versionhq.agent.inhouse_agents import vhq_task_evaluator
-        self.responsible_agent = vhq_task_evaluator
+        self.eval_by = vhq_task_evaluator
         return self
 
 
@@ -88,7 +87,7 @@ class Evaluation(BaseModel):
         """
         Create and store evaluation results in the memory metadata
         """
-        eval_by = self.responsible_agent.role if self.responsible_agent else None
+        eval_by = self.eval_by.role if self.eval_by else None
         score = self.aggregate_score
         eval_criteria = ", ".join([item.criteria for item in self.items]) if self.items else None
         suggestion = self.suggestion_summary

versionhq/task/formation.py

@@ -1,11 +1,11 @@
-from typing import List
+from typing import List, Type
 from enum import Enum
 
 from pydantic import BaseModel
 
 from versionhq.task.model import Task
 from versionhq.agent.model import Agent
-from versionhq.team.model import Team, TeamMember, Formation
+from versionhq.team.model import Team, Member, Formation
 from versionhq.agent.inhouse_agents  import vhq_formation_planner
 from versionhq._utils import Logger
 
@@ -15,10 +15,10 @@ def form_agent_network(
         expected_outcome: str,
         agents: List[Agent] = None,
         context: str = None,
-        formation: Formation = None
+        formation: Type[Formation] = None
     ) -> Team | None:
     """
-    Make a formation of agents from the given task description, agents (optional), context (optional), and expected outcome (optional).
+    Make a formation of agents from the given task description, expected outcome, agents (optional), and context (optional).
     """
 
     if not task:
@@ -29,8 +29,37 @@ def form_agent_network(
         Logger(verbose=True).log(level="error", message="Missing expected outcome.", color="red")
         return None
 
+    if formation:
+        try:
+            match formation:
+                case Formation():
+                    if formation == Formation.UNDEFINED:
+                        formation = None
+                    else:
+                        pass
+
+                case str():
+                    matched = [item for item in Formation._member_names_ if item == formation.upper()]
+                    if matched:
+                        formation = getattr(Formation, matched[0])
+                    else:
+                        # Formation._generate_next_value_(name=f"CUSTOM_{formation.upper()}", start=100, count=6, last_values=Formation.HYBRID.name)
+                        Logger(verbose=True).log(level="warning", message=f"The formation {formation} is invalid. We'll recreate a valid formation.", color="yellow")
+                        formation = None
+
+                case int() | float():
+                    formation = Formation(int(formation))
+
+                case _:
+                    Logger(verbose=True).log(level="warning", message=f"The formation {formation} is invalid. We'll recreate a valid formation.", color="yellow")
+                    formation = None
+
+        except Exception as e:
+            Logger(verbose=True).log(level="warning", message=f"The formation {formation} is invalid: {str(e)}. We'll recreate a formation.", color="yellow")
+            formation = None
 
     try:
+        prompt_formation = formation.name if formation and isinstance(formation, Formation) else f"Select the best formation to effectively execute the tasks from the given Enum sets: {str(Formation.__dict__)}."
         class Outcome(BaseModel):
             formation: Enum
             agent_roles: list[str]
@@ -42,73 +71,78 @@ def form_agent_network(
     Create a team of specialized agents designed to automate the following task and deliver the expected outcome. Consider the necessary roles for each agent with a clear task description. If you think we neeed a leader to handle the automation, return a leader_agent role as well, but if not, leave the a leader_agent role blank.
     Task: {str(task)}
     Expected outcome: {str(expected_outcome)}
+    Formation: {prompt_formation}
             """,
             pydantic_output=Outcome
         )
 
-        if formation:
-            vhq_task.description += f"Select 1 formation you think the best from the given Enum sets: {str(Formation.__dict__)}"
-
         if agents:
             vhq_task.description += "Consider adding following agents in the formation: " + ", ".join([agent.role for agent in agents if isinstance(agent, Agent)])
 
         res = vhq_task.execute_sync(agent=vhq_formation_planner, context=context)
-        formation_ = Formation.SUPERVISING
+        _formation = Formation.SUPERVISING
 
         if res.pydantic:
             formation_keys = [k for k, v in Formation._member_map_.items() if k == res.pydantic.formation.upper()]
 
             if formation_keys:
-                formation_ = Formation[formation_keys[0]]
+                _formation = Formation[formation_keys[0]]
 
             created_agents = [Agent(role=item, goal=item) for item in res.pydantic.agent_roles]
             created_tasks = [Task(description=item) for item in res.pydantic.task_descriptions]
+
             team_tasks = []
             members = []
             leader = str(res.pydantic.leader_agent)
 
             for i in range(len(created_agents)):
-                is_manager = bool(created_agents[i].role.lower() in leader.lower())
-                member = TeamMember(agent=created_agents[i], is_manager=is_manager)
+                is_manager = bool(created_agents[i].role.lower() == leader.lower())
+                member = Member(agent=created_agents[i], is_manager=is_manager)
+
+                if len(created_tasks) >= i and created_tasks[i]:
+                    member.tasks.append(created_tasks[i])
+
+                members.append(member)
 
-                if len(created_tasks) >= i:
-                    member.task = created_tasks[i]
-                    members.append(member)
 
             if len(created_agents) < len(created_tasks):
-                team_tasks.extend(created_tasks[len(created_agents) - 1:len(created_tasks)])
+                team_tasks.extend(created_tasks[len(created_agents):len(created_tasks)])
 
             members.sort(key=lambda x: x.is_manager == False)
-            team = Team(members=members, formation=formation_)
+            team = Team( members=members, formation=_formation,  team_tasks=team_tasks, planner_llm=vhq_formation_planner.llm)
             return team
 
         else:
-            formation_keys = [k for k, v in Formation._member_map_.items() if k == res.json_dict["formation"].upper()]
+            res = res.json_dict
+            formation_keys = [k for k, v in Formation._member_map_.items() if k == res["formation"].upper()]
 
             if formation_keys:
-                formation_ = Formation[formation_keys[0]]
+                _formation = Formation[formation_keys[0]]
+
+            created_agents = [Agent(role=item, goal=item) for item in res["agent_roles"]]
+            created_tasks = [Task(description=item) for item in res["task_descriptions"]]
 
-            created_agents = [Agent(role=item, goal=item) for item in res.json_dict["agent_roles"]]
-            created_tasks = [Task(description=item) for item in res.json_dict["task_descriptions"]]
             team_tasks = []
             members = []
-            leader = str(res.json_dict["leader_agent"])
+            leader = str(res["leader_agent"])
 
             for i in range(len(created_agents)):
-                is_manager = bool(created_agents[i].role.lower() in leader.lower())
-                member = TeamMember(agent=created_agents[i], is_manager=is_manager)
+                is_manager = bool(created_agents[i].role.lower() == leader.lower())
+                member = Member(agent=created_agents[i], is_manager=is_manager)
+
+                if len(created_tasks) >= i and created_tasks[i]:
+                    member.tasks.append(created_tasks[i])
 
-                if len(created_tasks) >= i:
-                    member.task = created_tasks[i]
-                    members.append(member)
+                members.append(member)
 
             if len(created_agents) < len(created_tasks):
-                team_tasks.extend(created_tasks[len(created_agents) - 1:len(created_tasks)])
+                team_tasks.extend(created_tasks[len(created_agents):len(created_tasks)])
 
-            members.sort(key=lambda x: x.is_manager == True)
-            team = Team(members=members, formation=formation_)
+            members.sort(key=lambda x: x.is_manager == False)
+            team = Team( members=members, formation=_formation,  team_tasks=team_tasks, planner_llm=vhq_formation_planner.llm)
             return team
 
+
     except Exception as e:
-        Logger(verbose=True).log(level="error", message=f"Failed to create an agent network - return None. You can try with solo agent. Error: {str(e)}", color="red")
+        Logger(verbose=True).log(level="error", message=f"Failed to create a agent network - return None. You can try with solo agent. Error: {str(e)}", color="red")
         return None

versionhq/task/log_handler.py

@@ -45,7 +45,7 @@ class TaskOutputStorageHandler:
             output_to_store = dict(
                 description=str(task.description),
                 raw=str(task.output.raw),
-                responsible_agent=str(task.processed_by_agents),
+                responsible_agent=str(task.processed_agents),
             )
 
         self.storage.add(task=task, output=output_to_store, task_index=task_index, was_replayed=was_replayed, inputs=inputs)

versionhq/task/model.py

@@ -203,7 +203,7 @@ class TaskOutput(BaseModel):
                 description=EVALUATE.format(task_description=task.description, task_output=self.raw, eval_criteria=str(item)),
                 pydantic_output=EvaluationItem
             )
-            res = task_eval.execute_sync(agent=self.evaluation.responsible_agent)
+            res = task_eval.execute_sync(agent=self.evaluation.eval_by)
 
             if res.pydantic:
                 item = EvaluationItem(score=res.pydantic.score, suggestion=res.pydantic.suggestion, criteria=res.pydantic.criteria)
@@ -241,10 +241,7 @@ class TaskOutput(BaseModel):
 
 class Task(BaseModel):
     """
-    Task to be executed by agents or teams.
-    Each task must have a description.
-    Default response is JSON string that strictly follows `response_fields` - and will be stored in TaskOuput.raw / json_dict.
-    When `pydantic_output` is provided, we prioritize them and store raw (json string), json_dict, pydantic in the TaskOutput class.
+    A class that stores independent task information.
     """
 
     __hash__ = object.__hash__
@@ -282,7 +279,7 @@ class Task(BaseModel):
     eval_criteria: Optional[List[str]] = Field(default_factory=list, description="criteria to evaluate the outcome. i.e., fit to the brand tone")
 
     # recording
-    processed_by_agents: Set[str] = Field(default_factory=set, description="store responsible agents' roles")
+    processed_agents: Set[str] = Field(default_factory=set, description="store roles of the agents that executed the task")
     tools_errors: int = 0
     delegations: int = 0
     latency: int | float = 0 # job latency in sec
@@ -640,7 +637,7 @@ Ref. Output image: {output_formats_to_follow}
 
         self.latency = (ended_at - started_at).total_seconds()
         self.output = task_output
-        self.processed_by_agents.add(agent.role)
+        self.processed_agents.add(agent.role)
 
         if self.should_evaluate:
             task_output.evaluate(task=self, latency=self.latency, tokens=self.tokens)