versionhq 1.2.1.16__py3-none-any.whl → 1.2.1.18__py3-none-any.whl

versionhq/__init__.py

@@ -27,11 +27,11 @@ from versionhq.tool.composio_tool import ComposioHandler
 from versionhq.memory.contextual_memory import ContextualMemory
 from versionhq.memory.model import ShortTermMemory,LongTermMemory, UserMemory, MemoryItem
 
-from versionhq.task.formation import form_agent_network
+from versionhq.agent_network.formation import form_agent_network
 from versionhq.task_graph.draft import workflow
 
 
-__version__ = "1.2.1.16"
+__version__ = "1.2.1.18"
 __all__ = [
     "Agent",
 

versionhq/_utils/process_config.py

@@ -8,7 +8,7 @@ def process_config(values_to_update: Dict[str, Any], model_class: Type[BaseModel
     Refer to the Pydantic model class for field validation.
     """
 
-    config = values_to_update.pop("config", {})
+    config = values_to_update.pop("config") if "config" in values_to_update else {}
 
     if config:
         for k, v in config.items():

versionhq/agent/model.py

@@ -91,7 +91,7 @@ class Agent(BaseModel):
     user_prompt_template: Optional[str] = Field(default=None, description="abs. file path to user prompt template")
 
     # task execution rules
-    network: Optional[List[Any]] = Field(default=None, description="store a list of agent networks that the agent belong as a member")
+    networks: Optional[List[Any]] = Field(default_factory=list, description="store a list of agent networks that the agent belong as a member")
     allow_delegation: bool = Field(default=False, description="whether to delegate the task to another agent")
     max_retry_limit: int = Field(default=2, description="max. number of task retries when an error occurs")
     maxit: Optional[int] = Field(default=25, description="max. number of total optimization loops conducted when an error occurs")
@@ -149,94 +149,6 @@ class Agent(BaseModel):
         return self
 
 
-    def _convert_to_llm_object(self, llm: Any = None) -> LLM:
-        """
-        Convert the given value to LLM object.
-        When `llm` is dict or self.llm_config is not None, add these values to the LLM object after validating them.
-        """
-        llm = llm if llm else self.llm if self.llm else DEFAULT_MODEL_NAME
-
-        if not llm:
-            pass
-
-        match llm:
-            case LLM():
-                return self._set_llm_params(llm=llm, config=self.llm_config)
-
-            case str():
-                llm_obj = LLM(model=llm)
-                return self._set_llm_params(llm=llm_obj, config=self.llm_config)
-
-            case dict():
-                model_name = llm.pop("model_name", llm.pop("deployment_name", str(llm)))
-                llm_obj = LLM(model=model_name if model_name else DEFAULT_MODEL_NAME)
-                config = llm.update(self.llm_config) if self.llm_config else llm
-                return self._set_llm_params(llm_obj, config=config)
-
-            case _:
-                model_name = (getattr(self.llm, "model_name") or getattr(self.llm, "deployment_name") or str(self.llm))
-                llm_obj = LLM(model=model_name if model_name else DEFAULT_MODEL_NAME)
-                llm_params = {
-                    "max_tokens": (getattr(llm, "max_tokens") or 3000),
-                    "timeout": getattr(llm, "timeout", self.max_execution_time),
-                    "callbacks": getattr(llm, "callbacks", None),
-                    "temperature": getattr(llm, "temperature", None),
-                    "logprobs": getattr(llm, "logprobs", None),
-                    "api_key": getattr(llm, "api_key", os.environ.get("LITELLM_API_KEY", None)),
-                    "base_url": getattr(llm, "base_url", None),
-                }
-                config = llm_params.update(self.llm_config) if self.llm_config else llm_params
-                return self._set_llm_params(llm=llm_obj, config=config)
-
-
-    def _set_llm_params(self, llm: LLM, config: Dict[str, Any] = None) -> LLM:
-        """
-        Add valid params to the LLM object.
-        """
-
-        import litellm
-        from versionhq.llm.llm_vars import PARAMS
-
-        valid_config = {k: v for k, v in config.items() if v} if config else {}
-
-        if valid_config:
-            valid_keys = list()
-            try:
-                valid_keys = litellm.get_supported_openai_params(model=llm.model, custom_llm_provider=self.endpoint_provider, request_type="chat_completion")
-                if not valid_keys:
-                    valid_keys = PARAMS.get("common")
-            except:
-                valid_keys = PARAMS.get("common")
-
-            valid_keys += PARAMS.get("litellm")
-
-            for key in valid_keys:
-                if key in valid_config and valid_config[key]:
-                    val = valid_config[key]
-                    if [key == k for k, v in LLM.model_fields.items()]:
-                        setattr(llm, key, val)
-                    else:
-                        llm.other_valid_config.update({ key: val})
-
-
-        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 llm.provider is None:
-            provider_name = llm.model.split("/")[0]
-            valid_provider = provider_name if provider_name in PROVIDERS else None
-            llm.provider = valid_provider
-
-        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
-
-        return llm
-
-
     @model_validator(mode="after")
     def set_up_tools(self) -> Self:
         """
@@ -369,6 +281,94 @@ class Agent(BaseModel):
         return self
 
 
+    def _convert_to_llm_object(self, llm: Any = None) -> LLM:
+        """
+        Convert the given value to LLM object.
+        When `llm` is dict or self.llm_config is not None, add these values to the LLM object after validating them.
+        """
+        llm = llm if llm else self.llm if self.llm else DEFAULT_MODEL_NAME
+
+        if not llm:
+            pass
+
+        match llm:
+            case LLM():
+                return self._set_llm_params(llm=llm, config=self.llm_config)
+
+            case str():
+                llm_obj = LLM(model=llm)
+                return self._set_llm_params(llm=llm_obj, config=self.llm_config)
+
+            case dict():
+                model_name = llm.pop("model_name", llm.pop("deployment_name", str(llm)))
+                llm_obj = LLM(model=model_name if model_name else DEFAULT_MODEL_NAME)
+                config = llm.update(self.llm_config) if self.llm_config else llm
+                return self._set_llm_params(llm_obj, config=config)
+
+            case _:
+                model_name = (getattr(self.llm, "model_name") or getattr(self.llm, "deployment_name") or str(self.llm))
+                llm_obj = LLM(model=model_name if model_name else DEFAULT_MODEL_NAME)
+                llm_params = {
+                    "max_tokens": (getattr(llm, "max_tokens") or 3000),
+                    "timeout": getattr(llm, "timeout", self.max_execution_time),
+                    "callbacks": getattr(llm, "callbacks", None),
+                    "temperature": getattr(llm, "temperature", None),
+                    "logprobs": getattr(llm, "logprobs", None),
+                    "api_key": getattr(llm, "api_key", os.environ.get("LITELLM_API_KEY", None)),
+                    "base_url": getattr(llm, "base_url", None),
+                }
+                config = llm_params.update(self.llm_config) if self.llm_config else llm_params
+                return self._set_llm_params(llm=llm_obj, config=config)
+
+
+    def _set_llm_params(self, llm: LLM, config: Dict[str, Any] = None) -> LLM:
+        """
+        Add valid params to the LLM object.
+        """
+
+        import litellm
+        from versionhq.llm.llm_vars import PARAMS
+
+        valid_config = {k: v for k, v in config.items() if v} if config else {}
+
+        if valid_config:
+            valid_keys = list()
+            try:
+                valid_keys = litellm.get_supported_openai_params(model=llm.model, custom_llm_provider=self.endpoint_provider, request_type="chat_completion")
+                if not valid_keys:
+                    valid_keys = PARAMS.get("common")
+            except:
+                valid_keys = PARAMS.get("common")
+
+            valid_keys += PARAMS.get("litellm")
+
+            for key in valid_keys:
+                if key in valid_config and valid_config[key]:
+                    val = valid_config[key]
+                    if [key == k for k, v in LLM.model_fields.items()]:
+                        setattr(llm, key, val)
+                    else:
+                        llm.other_valid_config.update({ key: val})
+
+
+        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 llm.provider is None:
+            provider_name = llm.model.split("/")[0]
+            valid_provider = provider_name if provider_name in PROVIDERS else None
+            llm.provider = valid_provider
+
+        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
+
+        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.)
@@ -567,7 +567,7 @@ class Agent(BaseModel):
 
 
         ## comment out for now
-        # if self.network and self.network._train:
+        # if self.networks and self.networks._train:
         #     task_prompt = self._training_handler(task_prompt=task_prompt)
         # else:
         #     task_prompt = self._use_trained_data(task_prompt=task_prompt)
@@ -599,3 +599,6 @@ class Agent(BaseModel):
 
     def __repr__(self):
         return f"Agent(role={self.role}, goal={self.goal}"
+
+    def __str__(self):
+        return super().__str__()

versionhq/agent_network/formation.py

@@ -0,0 +1,157 @@
+from typing import List, Type
+from enum import Enum
+
+from pydantic import BaseModel, create_model, Field
+
+from versionhq.task.model import Task
+from versionhq.agent.model import Agent
+from versionhq.agent_network.model import AgentNetwork, Member, Formation
+from versionhq.agent.inhouse_agents  import vhq_formation_planner
+from versionhq._utils import Logger
+
+
+def form_agent_network(
+        task: str,
+        expected_outcome: str | Type[BaseModel],
+        agents: List[Agent] = None,
+        context: str = None,
+        formation: Type[Formation] = None
+    ) -> AgentNetwork | None:
+    """
+    Make a formation of agents from the given task description, expected outcome, agents (optional), and context (optional).
+    """
+
+    if not task:
+        Logger(verbose=True).log(level="error", message="Missing task description.", color="red")
+        return None
+
+    if not expected_outcome:
+        Logger(verbose=True).log(level="error", message="Missing expected outcome.", color="red")
+        return None
+
+    if formation:
+        try:
+            match formation:
+                case Formation():
+                    pass
+
+                case str():
+                    matched = [item for item in Formation.s_ 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__)}."
+
+    prompt_expected_outcome = expected_outcome if isinstance(expected_outcome, str) else expected_outcome.model_dump_json()
+
+    class Outcome(BaseModel):
+        formation: Enum
+        agent_roles: list[str]
+        task_descriptions: list[str]
+        task_outcomes: list[list[str]]
+        leader_agent: str
+
+    vhq_task = Task(
+        description=f"Design a team of specialized agents to fully automate the following task and achieve the expected outcome. For each agent, define its role, task description, and expected outputs via the task with items in a list. Then specify the team formation if the formation is not given. If you think SUPERVISING or HYBRID is the best formation, include a leader_agent role, else leave the leader_agent role blank.\nTask: {str(task)}\nExpected outcome: {prompt_expected_outcome}\nFormation: {prompt_formation}",
+        pydantic_output=Outcome
+    )
+
+    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(agent=vhq_formation_planner, context=context)
+
+    formation_keys = ([k for k in Formation._member_map_.keys() if k == res.pydantic.formation.upper()]
+                      if res.pydantic else [k for k in Formation._member_map_.keys() if k == res.json_dict["formation"].upper()])
+    _formation = Formation[formation_keys[0]] if formation_keys else Formation.SUPERVISING
+
+    network_tasks = []
+    members = []
+    leader = str(res.pydantic.leader_agent) if res.pydantic else str(res.json_dict["leader_agent"])
+
+    created_agents = [Agent(role=item, goal=item) for item in res.pydantic.agent_roles]
+    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]:
+                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.pydantic.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())
+            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())
+                member_w_o_task = Member(agent=created_agents[i], is_manager=is_manager)
+                members.append(member_w_o_task)
+            except:
+                pass
+
+    elif len(created_tasks) > len(created_agents):
+        for i in range(len(created_agents)):
+            is_manager = 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)
+        members.append(manager)
+
+    members.sort(key=lambda x: x.is_manager == False)
+    network = AgentNetwork(members=members, formation=_formation, network_tasks=network_tasks)
+
+    Logger().log(level="info", message=f"Successfully created a agent network: {str(network.id)} with {len(network.members)} agents.", color="blue")
+
+    return network
+
+
+    # except Exception as e:
+    #     Logger().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/agent_network/model.py

@@ -28,7 +28,6 @@ warnings.filterwarnings("ignore", category=SyntaxWarning, module="pysbd")
 
 
 class Formation(str, Enum):
-    UNDEFINED = 0
     SOLO = 1
     SUPERVISING = 2
     SQUAD = 3
@@ -96,7 +95,6 @@ class AgentNetwork(BaseModel):
 
     __hash__ = object.__hash__
     _execution_span: Any = PrivateAttr()
-    _logger: Logger = PrivateAttr(default_factory=lambda: Logger(verbose=True))
     _inputs: Optional[Dict[str, Any]] = PrivateAttr(default=None)
 
     id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
@@ -167,12 +165,12 @@ class AgentNetwork(BaseModel):
         """
         if self.process == TaskHandlingProcess.HIERARCHY or self.formation == Formation.SUPERVISING:
             if not self.managers:
-                self._logger.log(level="error", message="The process or formation created needs at least 1 manager agent.", color="red")
+                Logger().log(level="error", message="The process or formation created needs at least 1 manager agent.", color="red")
                 raise PydanticCustomError("missing_manager", "`manager` is required when using hierarchical process.", {})
 
         ## comment out for the formation flexibilities
         # if self.managers and (self.manager_tasks is None or self.network_tasks is None):
-        #     self._logger.log(level="error", message="The manager is idling. At least 1 task needs to be assigned to the manager.", color="red")
+        #     Logger().log(level="error", message="The manager is idling. At least 1 task needs to be assigned to the manager.", color="red")
         #     raise PydanticCustomError("missing_manager_task", "manager needs to have at least one manager task or network task.", {})
 
         return self
@@ -186,10 +184,11 @@ class AgentNetwork(BaseModel):
         if self.process == TaskHandlingProcess.SEQUENT and self.network_tasks is None:
             for task in self.tasks:
                 if not [member.task == task for member in self.members]:
-                    self._logger.log(level="error", message=f"The following task needs a dedicated agent to be assinged: {task.description}", color="red")
+                    Logger().log(level="error", message=f"The following task needs a dedicated agent to be assinged: {task.description}", color="red")
                     raise PydanticCustomError("missing_agent_in_task", "Sequential process error: Agent is missing the task", {})
         return self
 
+
     @model_validator(mode="after")
     def validate_end_with_at_most_one_async_task(self):
         """
@@ -371,7 +370,7 @@ class AgentNetwork(BaseModel):
             task_outputs = self._process_async_tasks(futures, was_replayed)
 
         if not task_outputs:
-            self._logger.log(level="error", message="Missing task outputs.", color="red")
+            Logger().log(level="error", message="Missing task outputs.", color="red")
             raise ValueError("Missing task outputs")
 
         final_task_output = lead_task_output if lead_task_output is not None else task_outputs[0] #! REFINEME
@@ -399,12 +398,12 @@ class AgentNetwork(BaseModel):
             self._assign_tasks()
 
         if kwargs_pre is not None:
-            for func in self.pre_launch_callbacks:
+            for func in self.pre_launch_callbacks: # signature check
                 func(**kwargs_pre)
 
         for member in self.members:
             agent = member.agent
-            agent.network = self
+            agent.networks.append(self)
 
             if self.step_callback:
                 agent.callbacks.append(self.step_callback)

versionhq/task/model.py

@@ -281,7 +281,7 @@ class Task(BaseModel):
 
     # executing
     execution_type: TaskExecutionType = Field(default=TaskExecutionType.SYNC)
-    allow_delegation: bool = Field(default=False, description="ask other agents for help and run the task instead")
+    allow_delegation: bool = Field(default=False, description="whether to delegate the task to another agent")
     callback: Optional[Callable] = Field(default=None, description="callback to be executed after the task is completed.")
     callback_kwargs: Optional[Dict[str, Any]] = Field(default_factory=dict, description="kwargs for the callback when the callback is callable")
 
@@ -574,6 +574,36 @@ Ref. Output image: {output_formats_to_follow}
         return agent
 
 
+    def _select_agent_to_delegate(self, agent: Any = None) -> Any | None: # return agent object or None
+        """
+        Creates or selects an agent to delegate the given task and returns Agent object else None.
+        """
+
+        from versionhq.agent.model import Agent
+
+        if not self.allow_delegation:
+            return None
+
+        agent_to_delegate: InstanceOf[Agent] = None
+
+        if not agent:
+            agent_to_delegate = self._build_agent_from_task()
+
+        elif agent and not agent.networks:
+            agent_to_delegate = Agent(role="vhq-Delegated-Agent", goal=agent.goal, llm=agent.llm)
+
+        else:
+            _managers = []
+            _members = []
+            for network in agent.networks:
+                _managers.extend(member.agent for member in network.members if member.is_manager)
+                _members.extend(member.agent for member in network.members if not member.is_manager)
+
+            agent_to_delegate = _managers[0] if _managers else _members[0] if _members else Agent(role="vhq-Delegated-Agent", goal=agent.goal, llm=agent.llm)
+
+        return agent_to_delegate
+
+
     # task execution
     def execute(
             self, type: TaskExecutionType = None, agent: Optional["vhq.Agent"] = None, context: Optional[Any] = None
@@ -635,19 +665,7 @@ Ref. Output image: {output_formats_to_follow}
                     task_tools.append(item)
 
         if self.allow_delegation == True:
-            agent_to_delegate = None
-
-            if hasattr(agent, "network") and isinstance(agent.network, AgentNetwork):
-                if agent.network.managers:
-                    idling_manager_agents = [manager.agent for manager in agent.network.managers if manager.is_idling]
-                    agent_to_delegate = idling_manager_agents[0] if idling_manager_agents else agent.network.managers[0]
-                else:
-                    peers = [member.agent for member in agent.network.members if member.is_manager == False and member.agent.id is not agent.id]
-                    if len(peers) > 0:
-                        agent_to_delegate = peers[0]
-            else:
-                agent_to_delegate = Agent(role="vhq-Delegated-Agent", goal=agent.goal, llm=agent.llm)
-
+            agent_to_delegate = self._select_agent_to_delegate(agent=agent)
             agent = agent_to_delegate
             self.delegations += 1
 

{versionhq-1.2.1.16.dist-info → versionhq-1.2.1.18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: versionhq
-Version: 1.2.1.16
+Version: 1.2.1.18
 Summary: An agentic orchestration framework for building agent networks that handle task automation.
 Author-email: Kuriko Iwai <kuriko@versi0n.io>
 License: MIT License

{versionhq-1.2.1.16.dist-info → versionhq-1.2.1.18.dist-info}/RECORD

@@ -1,19 +1,20 @@
-versionhq/__init__.py,sha256=X8no15wt1eRD5MvPgotKJer6Zl8fu7CEm2X85NX0VMc,2883
+versionhq/__init__.py,sha256=I1z2OKVSflVHMiWtAsm5qE2-pmpxTtiMQhcytzInHas,2892
 versionhq/_utils/__init__.py,sha256=dzoZr4cBlh-2QZuPzTdehPUCe9lP1dmRtauD7qTjUaA,158
 versionhq/_utils/i18n.py,sha256=TwA_PnYfDLA6VqlUDPuybdV9lgi3Frh_ASsb_X8jJo8,1483
 versionhq/_utils/logger.py,sha256=zgogTwAY-ujDLrdryAKhdtoaNe1nOFajmEN0V8aMR34,3155
-versionhq/_utils/process_config.py,sha256=jbPGXK2Kb4iyCugJ3FwRJuU0wL5Trq2x4xFQz2uOyFY,746
+versionhq/_utils/process_config.py,sha256=YTGY_erW335RfceQfzS18YAqq-AAb-iSvKSjN7noD2E,782
 versionhq/_utils/usage_metrics.py,sha256=NXF18dn5NNvGK7EsQ4AAghpR8ppYOjMx6ABenLLHnmM,1066
 versionhq/_utils/vars.py,sha256=bZ5Dx_bFKlt3hi4-NNGXqdk7B23If_WaTIju2fiTyPQ,57
 versionhq/agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/agent/inhouse_agents.py,sha256=vupO1viYqVb7sKohIE1zThu6JArhh5JLo5LBeSnh0kM,2534
-versionhq/agent/model.py,sha256=ReuQLuLQZ87TyzMKdQaqfDX496waLascBt2Ebw69QAY,25593
+versionhq/agent/model.py,sha256=acAFIDmCbSVbMIf0Qlp9lzhdF0f_201havj3RnYj0xw,25661
 versionhq/agent/parser.py,sha256=riG0dkdQCxH7uJ0AbdVdg7WvL0BXhUgJht0VtQvxJBc,4082
 versionhq/agent/rpm_controller.py,sha256=grezIxyBci_lDlwAlgWFRyR5KOocXeOhYkgN02dNFNE,2360
 versionhq/agent/TEMPLATES/Backstory.py,sha256=IAhGnnt6VUMe3wO6IzeyZPDNu7XE7Uiu3VEXUreOcKs,532
 versionhq/agent/TEMPLATES/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/agent_network/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-versionhq/agent_network/model.py,sha256=P3Ntr_OIK60EXjEfaEm31HTBFypZfVr__0aC4VBt9G0,19353
+versionhq/agent_network/formation.py,sha256=QHLbv4XgbmMEQpdoHGrV6_CQOW3kIe7Jp32G0HgpA90,7418
+versionhq/agent_network/model.py,sha256=hjtYIopAN52nStcM6TlV0b6ulRMrmzKH7jIkzNmZHDE,19265
 versionhq/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/clients/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/clients/customer/__init__.py,sha256=-YXh1FQfvpfLacK8SUC7bD7Wx_eIEi4yrkCC_cUasFg,217
@@ -44,10 +45,9 @@ versionhq/storage/task_output_storage.py,sha256=E1t_Fkt78dPYIOl3MP7LfQ8oGtjlzxBu
 versionhq/storage/utils.py,sha256=ByYXPoEIGJYLUqz-DWjbCAnneNrH1otiYbp12SCILpM,747
 versionhq/task/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/task/evaluate.py,sha256=WdUgjbZL62XrxyWe5MTz29scfzwmuAHGxJ7GvAB8Fmk,3954
-versionhq/task/formation.py,sha256=WH604q9bRmWH7KQCrk2qKJwisCopYX5CjJvsj4TgFjI,6894
 versionhq/task/formatter.py,sha256=N8Kmk9vtrMtBdgJ8J7RmlKNMdZWSmV8O1bDexmCWgU0,643
 versionhq/task/log_handler.py,sha256=LT7YnO7gcPR9IZS7eRvMjnHh8crMBFtqduxd8dxIbkk,1680
-versionhq/task/model.py,sha256=i0MDTS9-htIygL7Q8CTOrG8Zt0gPcqQiS4wacmecqAc,28540
+versionhq/task/model.py,sha256=KshCysteol3ggfotZMfFn192dMYALg8lvjiGpyLUVQA,28948
 versionhq/task/structured_response.py,sha256=4q-hQPu7oMMHHXEzh9YW4SJ7N5eCZ7OfZ65juyl_jCI,5000
 versionhq/task/TEMPLATES/Description.py,sha256=V-4kh8xpQTKOcDMi2xnuP-fcNk6kuoz1_5tYBlDLQWQ,420
 versionhq/task_graph/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -61,8 +61,8 @@ versionhq/tool/composio_tool_vars.py,sha256=FvBuEXsOQUYnN7RTFxT20kAkiEYkxWKkiVtg
 versionhq/tool/decorator.py,sha256=C4ZM7Xi2gwtEMaSeRo-geo_g_MAkY77WkSLkAuY0AyI,1205
 versionhq/tool/model.py,sha256=PO4zNWBZcJhYVur381YL1dy6zqurio2jWjtbxOxZMGI,12194
 versionhq/tool/tool_handler.py,sha256=2m41K8qo5bGCCbwMFferEjT-XZ-mE9F0mDUOBkgivOI,1416
-versionhq-1.2.1.16.dist-info/LICENSE,sha256=cRoGGdM73IiDs6nDWKqPlgSv7aR4n-qBXYnJlCMHCeE,1082
-versionhq-1.2.1.16.dist-info/METADATA,sha256=hAoTlAANrgYU-5ybybIvcQsKn_q7XAQmljyWh6bnw4Y,22033
-versionhq-1.2.1.16.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-versionhq-1.2.1.16.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
-versionhq-1.2.1.16.dist-info/RECORD,,
+versionhq-1.2.1.18.dist-info/LICENSE,sha256=cRoGGdM73IiDs6nDWKqPlgSv7aR4n-qBXYnJlCMHCeE,1082
+versionhq-1.2.1.18.dist-info/METADATA,sha256=NvKh5tYpJbFp0SHQaukksKnHOCrzO2SBGJfO0rJlTZM,22033
+versionhq-1.2.1.18.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+versionhq-1.2.1.18.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
+versionhq-1.2.1.18.dist-info/RECORD,,

versionhq/task/formation.py

@@ -1,159 +0,0 @@
-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.agent_network.model import AgentNetwork, Member, Formation
-from versionhq.agent.inhouse_agents  import vhq_formation_planner
-from versionhq._utils import Logger
-
-
-def form_agent_network(
-        task: str,
-        expected_outcome: str,
-        agents: List[Agent] = None,
-        context: str = None,
-        formation: Type[Formation] = None
-    ) -> AgentNetwork | None:
-    """
-    Make a formation of agents from the given task description, expected outcome, agents (optional), and context (optional).
-    """
-
-    if not task:
-        Logger(verbose=True).log(level="error", message="Missing task description.", color="red")
-        return None
-
-    if not expected_outcome:
-        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.s_ 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]
-            task_descriptions: list[str]
-            leader_agent: str
-
-        vhq_task = Task(
-            description=f"""
-    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. When you have a leader_agent, the formation must be SUPERVISING or HYBRID.
-    Task: {str(task)}
-    Expected outcome: {str(expected_outcome)}
-    Formation: {prompt_formation}
-            """,
-            pydantic_output=Outcome
-        )
-
-        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(agent=vhq_formation_planner, context=context)
-        _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]]
-
-
-            network_tasks = []
-            members = []
-            leader = str(res.pydantic.leader_agent)
-
-            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]
-
-
-            for i in range(len(created_agents)):
-                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_agents) < len(created_tasks):
-                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)
-                members.append(manager)
-
-            members.sort(key=lambda x: x.is_manager == False)
-            network = AgentNetwork(members=members, formation=_formation, network_tasks=network_tasks)
-            return network
-
-        else:
-            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]]
-
-            created_agents = [Agent(role=item, goal=item) for item in res["agent_roles"]]
-            created_tasks = [Task(description=item) for item in res["task_descriptions"]]
-
-            network_tasks = []
-            members = []
-            leader = str(res["leader_agent"])
-
-            for i in range(len(created_agents)):
-                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_agents) < len(created_tasks):
-                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]:
-                member = Member(agent=Agent(role=leader, goal=leader), is_manager=True)
-                members.append(member)
-
-            members.sort(key=lambda x: x.is_manager == False)
-            network = AgentNetwork(members=members, formation=_formation,  network_tasks=network_tasks)
-
-            return network
-
-
-    except Exception as e:
-        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