versionhq 1.2.1.15__py3-none-any.whl → 1.2.1.17__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.15"
+__version__ = "1.2.1.17"
 __all__ = [
     "Agent",
 

versionhq/agent/inhouse_agents.py

@@ -10,7 +10,7 @@ vhq_client_manager = Agent(
     role="vhq-Client Manager",
     goal="Efficiently communicate with the client on the task progress",
     llm=DEFAULT_MODEL_NAME,
-    use_memory=True,
+    with_memory=True,
 )
 
 
@@ -21,7 +21,7 @@ vhq_task_evaluator = Agent(
     llm_config=dict(top_p=0.8, top_k=30, max_tokens=5000, temperature=0.9),
     maxit=1,
     max_retry_limit=1,
-    use_memory=True # refer past eval records of similar tasks
+    with_memory=True # refer past eval records of similar tasks
 )
 
 

versionhq/agent/model.py

@@ -60,7 +60,6 @@ class Agent(BaseModel):
     """
 
     __hash__ = object.__hash__
-    _logger: Logger = PrivateAttr(default_factory=lambda: Logger(verbose=True))
     _rpm_controller: Optional[RPMController] = PrivateAttr(default=None)
     _request_within_rpm_limit: Any = PrivateAttr(default=None)
     _token_process: TokenProcess = PrivateAttr(default_factory=TokenProcess)
@@ -76,39 +75,38 @@ class Agent(BaseModel):
 
     # knowledge
     knowledge_sources: Optional[List[BaseKnowledgeSource | Any]] = Field(default=None)
+    embedder_config: Optional[Dict[str, Any]] = Field(default=None, description="embedder configuration for knowledge sources")
     _knowledge: Optional[Knowledge] = PrivateAttr(default=None)
 
     # memory
-    use_memory: bool = Field(default=False, description="whether to store/use memory when executing the task")
-    memory_config: Optional[Dict[str, Any]] = Field(default=None, description="configuration for the memory. need to store user_id for UserMemory")
+    with_memory: bool = Field(default=False, description="whether to use memories during the task execution")
+    memory_config: Optional[Dict[str, Any]] = Field(default=None, description="memory config. needs to store user_id for UserMemory to work")
     short_term_memory: Optional[InstanceOf[ShortTermMemory]] = Field(default=None)
     long_term_memory: Optional[InstanceOf[LongTermMemory]] = Field(default=None)
     user_memory: Optional[InstanceOf[UserMemory]] = Field(default=None)
-    embedder_config: Optional[Dict[str, Any]] = Field(default=None, description="embedder configuration for the agent's knowledge")
 
     # 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")
+    developer_propmt_template: Optional[str] = Field(default=None, description="abs. file path to developer prompt template")
+    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")
-    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")
+    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")
     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)
-    function_calling_llm: str | InstanceOf[LLM] | Dict[str, Any] = Field(default=None)
-    respect_context_window: bool = Field(default=True,description="Keep messages under the context window size by summarizing content")
-    max_tokens: Optional[int] = Field(default=None, description="max. number of tokens for the agent's execution")
-    max_execution_time: Optional[int] = Field(default=None, description="max. execution time for an agent to execute a task")
+    func_calling_llm: str | InstanceOf[LLM] | Dict[str, Any] = Field(default=None)
+    respect_context_window: bool = Field(default=True,description="keep messages under the context window size")
+    max_execution_time: Optional[int] = Field(default=None, description="max. task execution time in seconds")
     max_rpm: Optional[int] = Field(default=None, description="max. number of requests per minute")
     llm_config: Optional[Dict[str, Any]] = Field(default=None, description="other llm config cascaded to the LLM model")
 
-    # cache, error, ops handling
-    formatting_errors: int = Field(default=0, description="number of formatting errors.")
+    # # cache, error, ops handling
+    # formatting_errors: int = Field(default=0, description="number of formatting errors.")
 
 
     @field_validator("id", mode="before")
@@ -136,18 +134,18 @@ class Agent(BaseModel):
     @model_validator(mode="after")
     def set_up_llm(self) -> Self:
         """
-        Set up `llm` and `function_calling_llm` as valid LLM objects using the given kwargs.
+        Set up `llm` and `func_calling_llm` as valid LLM objects using the given kwargs.
         """
         self.llm = self._convert_to_llm_object(llm=self.llm)
 
-        function_calling_llm = self.function_calling_llm if self.function_calling_llm else self.llm if self.llm else None
-        function_calling_llm = self._convert_to_llm_object(llm=function_calling_llm)
-        if function_calling_llm._supports_function_calling():
-            self.function_calling_llm = function_calling_llm
+        func_calling_llm = self.func_calling_llm if self.func_calling_llm else self.llm if self.llm else None
+        func_calling_llm = self._convert_to_llm_object(llm=func_calling_llm)
+        if func_calling_llm._supports_function_calling():
+            self.func_calling_llm = func_calling_llm
         elif self.llm._supports_function_calling():
-            self.function_calling_llm = self.llm
+            self.func_calling_llm = self.llm
         else:
-            self.function_calling_llm = self._convert_to_llm_object(llm=LLM(model=DEFAULT_MODEL_NAME))
+            self.func_calling_llm = self._convert_to_llm_object(llm=LLM(model=DEFAULT_MODEL_NAME))
         return self
 
 
@@ -179,7 +177,7 @@ class Agent(BaseModel):
                 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 self.max_tokens or 3000),
+                    "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),
@@ -222,7 +220,7 @@ class Agent(BaseModel):
 
 
         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
+        # 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]
@@ -262,7 +260,7 @@ class Agent(BaseModel):
                     tool_list.append(item)
 
                 else:
-                    self._logger.log(level="error", message=f"Tool {str(item)} is missing a function.", color="red")
+                    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
@@ -346,7 +344,7 @@ class Agent(BaseModel):
                 self._knowledge = Knowledge(sources=knowledge_sources, embedder_config=self.embedder_config, collection_name=collection_name)
 
             except:
-                self._logger.log(level="warning", message="We cannot find the format for the source. Add BaseKnowledgeSource objects instead.", color="yellow")
+                Logger().log(level="warning", message="We cannot find the format for the source. Add BaseKnowledgeSource objects instead.", color="yellow")
 
         return self
 
@@ -357,7 +355,7 @@ class Agent(BaseModel):
         Set up memories: stm, ltm, and um
         """
 
-        # if self.use_memory == True:
+        # if self.with_memory == True:
         self.long_term_memory = self.long_term_memory if self.long_term_memory else LongTermMemory()
         self.short_term_memory = self.short_term_memory if self.short_term_memory else ShortTermMemory(agent=self, embedder_config=self.embedder_config)
 
@@ -371,21 +369,13 @@ class Agent(BaseModel):
         return self
 
 
-    def _train(self) -> Self:
-        """
-        Fine-tuned the base model using OpenAI train framework.
-        """
-        if not isinstance(self.llm, LLM):
-            pass
-
-
-    def update_llm(self, llm: Any = None, llm_config: Optional[Dict[str, Any]] = None) -> Self:
+    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:
-            self._logger.log(level="error", message="Missing llm or llm_config values to update", color="red")
+            Logger().log(level="error", message="Missing llm or llm_config values to update", color="red")
             pass
 
         self.llm = llm
@@ -398,59 +388,15 @@ class Agent(BaseModel):
         return self.set_up_llm()
 
 
-    def update(self, **kwargs) -> Self:
+    def _train(self) -> Self:
         """
-        Update the existing agent. Address variables that require runnning set_up_x methods first, then update remaining variables.
+        Fine-tuned the base model using OpenAI train framework.
         """
-
-        if not kwargs:
-            self._logger.log(level="error", message="Missing values to update", color="red")
-            return self
-
-        for k, v in kwargs.items():
-            match k:
-                case "tools":
-                    self.tools = kwargs.get(k, self.tools)
-                    self.set_up_tools()
-
-                case "role" | "goal":
-                    self.role = kwargs.get("role", self.role)
-                    self.goal = kwargs.get("goal", self.goal)
-                    if not self.backstory:
-                        self.set_up_backstory()
-
-                    if self.backstory:
-                        self.backstory += f"new role: {self.role}, new goal: {self.goal}"
-
-                case "max_rpm":
-                    self.max_rpm = kwargs.get(k, self.max_rpm)
-                    self.set_up_rpm()
-
-                case "knowledge_sources":
-                    self.knowledge_sources = kwargs.get("knowledge_sources", self.knowledge_sources)
-                    self.set_up_knowledge()
-
-                case "use_memory" | "memory_config":
-                    self.use_memory = kwargs.get("use_memory", self.use_memory)
-                    self.memory_config = kwargs.get("memory_config", self.memory_config)
-                    self.set_up_memory()
-
-                case "llm" | "llm_config":
-                    self.llm = kwargs.get("llm", self.llm)
-                    self.llm_config = kwargs.get("llm_config", self.llm_config)
-                    self.update_llm(llm=self.llm, llm_config=self.llm_config)
-
-                case _:
-                    try:
-                        setattr(self, k, v)
-                    except Exception as e:
-                        self._logger.log(level="error", message=f"Failed to update the key: {k} We'll skip. Error: {str(e)}", color="red")
-                        pass
-
-        return self
+        if not isinstance(self.llm, LLM):
+            pass
 
 
-    def invoke(
+    def _invoke(
         self,
         prompts: str,
         response_format: Optional[Dict[str, Any]] = None,
@@ -477,21 +423,21 @@ class Agent(BaseModel):
             if self._rpm_controller and self.max_rpm:
                 self._rpm_controller.check_or_wait()
 
-            self._logger.log(level="info", message=f"Messages sent to the model: {messages}", color="blue")
+            Logger().log(level="info", message=f"Messages sent to the model: {messages}", color="blue")
 
             if tool_res_as_final:
-                raw_response = self.function_calling_llm.call(messages=messages, tools=tools, tool_res_as_final=True)
-                task.tokens = self.function_calling_llm._tokens
+                raw_response = self.func_calling_llm.call(messages=messages, tools=tools, tool_res_as_final=True)
+                task.tokens = self.func_calling_llm._tokens
             else:
                 raw_response = self.llm.call(messages=messages, response_format=response_format, tools=tools)
                 task.tokens = self.llm._tokens
 
             task_execution_counter += 1
-            self._logger.log(level="info", message=f"Agent response: {raw_response}", color="green")
+            Logger().log(level="info", message=f"Agent response: {raw_response}", color="green")
             return raw_response
 
         except Exception as e:
-            self._logger.log(level="error", message=f"An error occured. The agent will retry: {str(e)}", color="red")
+            Logger().log(level="error", message=f"An error occured. The agent will retry: {str(e)}", color="red")
 
             while not raw_response and task_execution_counter <= self.max_retry_limit:
                 while (not raw_response or raw_response == "" or raw_response is None) and iterations < self.maxit:
@@ -503,14 +449,89 @@ class Agent(BaseModel):
                     iterations += 1
 
                 task_execution_counter += 1
-                self._logger.log(level="info", message=f"Agent #{task_execution_counter} response: {raw_response}", color="green")
+                Logger().log(level="info", message=f"Agent #{task_execution_counter} response: {raw_response}", color="green")
                 return raw_response
 
             if not raw_response:
-                self._logger.log(level="error", message="Received None or empty response from the model", color="red")
+                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.")
 
 
+    def update(self, **kwargs) -> Self:
+        """
+        Update the existing agent. Address variables that require runnning set_up_x methods first, then update remaining variables.
+        """
+
+        if not kwargs:
+            Logger().log(level="error", message="Missing values to update", color="red")
+            return self
+
+        for k, v in kwargs.items():
+            match k:
+                case "tools":
+                    self.tools = kwargs.get(k, self.tools)
+                    self.set_up_tools()
+
+                case "role" | "goal":
+                    self.role = kwargs.get("role", self.role)
+                    self.goal = kwargs.get("goal", self.goal)
+                    if not self.backstory:
+                        self.set_up_backstory()
+
+                    if self.backstory:
+                        self.backstory += f"new role: {self.role}, new goal: {self.goal}"
+
+                case "max_rpm":
+                    self.max_rpm = kwargs.get(k, self.max_rpm)
+                    self.set_up_rpm()
+
+                case "knowledge_sources":
+                    self.knowledge_sources = kwargs.get("knowledge_sources", self.knowledge_sources)
+                    self.set_up_knowledge()
+
+                case "with_memory" | "memory_config":
+                    self.with_memory = kwargs.get("with_memory", self.with_memory)
+                    self.memory_config = kwargs.get("memory_config", self.memory_config)
+                    self.set_up_memory()
+
+                case "llm" | "llm_config":
+                    self.llm = kwargs.get("llm", self.llm)
+                    self.llm_config = kwargs.get("llm_config", self.llm_config)
+                    self._update_llm(llm=self.llm, llm_config=self.llm_config)
+
+                case _:
+                    try:
+                        setattr(self, k, v)
+                    except Exception as e:
+                        Logger().log(level="error", message=f"Failed to update the field: {k} We'll skip it. Error: {str(e)}", color="red")
+                        pass
+
+        return self
+
+
+    def start(self, context: Any = None, tool_res_as_final: bool = False) -> Any | None:
+        """
+        Defines and executes a task when it is not given and returns TaskOutput object.
+        """
+
+        if not self.goal or not self.role:
+            return None
+
+        from versionhq.task.model import Task
+
+        class Output(BaseModel):
+            result: str
+            steps: list[str]
+
+        task = Task(
+            description=f"Generate a simple result in a sentence to achieve the goal: {self.goal}. If needed, list up necessary steps in concise manner.",
+            pydantic_output=Output,
+            tool_res_as_final=tool_res_as_final,
+        )
+        res = task.execute(agent=self, context=context)
+        return res
+
+
     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.
@@ -534,7 +555,7 @@ class Agent(BaseModel):
                 if agent_knowledge_context:
                     task_prompt += agent_knowledge_context
 
-        if self.use_memory == True:
+        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
             )
@@ -546,14 +567,14 @@ 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)
 
         try:
             self._times_executed += 1
-            raw_response = self.invoke(
+            raw_response = self._invoke(
                 prompts=task_prompt,
                 response_format=task._structure_response_format(model_provider=self.llm.provider),
                 tools=tools,
@@ -563,11 +584,11 @@ class Agent(BaseModel):
 
         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")
+            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")
+                Logger().log(level="error", message=f"Max retry limit has exceeded.", color="red")
                 raise e
 
         if self.max_rpm and self._rpm_controller:
@@ -576,27 +597,5 @@ class Agent(BaseModel):
         return raw_response
 
 
-    def start(self, context: Any = None) -> Any | None:
-        """
-        Defines and executes a task when it is not given and returns TaskOutput object.
-        """
-
-        if not self.goal or not self.role:
-            return None
-
-        from versionhq.task.model import Task, ResponseField
-
-        class Output(BaseModel):
-            result: str
-            steps: list[str]
-
-        task = Task(
-            description=f"Generate a simple result in a sentence to achieve the goal: {self.goal}. If needed, list up necessary steps in concise manner.",
-            pydantic_output=Output
-        )
-        res = task.execute(agent=self, context=context)
-        return res
-
-
     def __repr__(self):
         return f"Agent(role={self.role}, goal={self.goal}"

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().replace(" ", "_").replace(":", "_")[0: 10]
+                        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().replace(" ", "_").replace(":", "_")[0: 10]
+                        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.append(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")
 
@@ -530,9 +530,9 @@ Ref. Output image: {output_formats_to_follow}
         from versionhq.agent.model import Agent
         from versionhq.memory.model import ShortTermMemory, MemoryMetadata, LongTermMemory
 
-        agent = agent if isinstance(agent, Agent) else Agent(role=str(agent), goal=str(agent), use_memory=True)
+        agent = agent if isinstance(agent, Agent) else Agent(role=str(agent), goal=str(agent), with_memory=True)
 
-        if agent.use_memory == False:
+        if agent.with_memory == False:
             return None
 
         try:
@@ -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/task_graph/draft.py

@@ -14,7 +14,7 @@ from versionhq.task_graph.model import TaskGraph, Task, DependencyType, Node
 from versionhq._utils.logger import Logger
 
 
-def workflow(final_output: Type[BaseModel], context: Any = None, human: bool = False, use_memory: bool = False) -> TaskGraph | None:
+def workflow(final_output: Type[BaseModel], context: Any = None, human: bool = False, with_memory: bool = False) -> TaskGraph | None:
     """
     Generate a TaskGraph object to generate the givne final_output most resource-efficiently.
     """
@@ -43,7 +43,7 @@ def workflow(final_output: Type[BaseModel], context: Any = None, human: bool = F
             ", ".join([k for k in DependencyType._member_map_.keys()]),
         ],
         llm="gemini-2.0",
-        use_memory=use_memory,
+        with_memory=with_memory,
         maxit=1,
         max_retry_limit=1,
     )

versionhq/tool/composio_tool.py

@@ -2,14 +2,13 @@ import os
 import uuid
 from abc import ABC
 from dotenv import load_dotenv
-from typing import Any, Callable, Type, get_args, get_origin, Optional, Tuple, Dict
+from typing import Any, Optional, Tuple, Dict
 from typing_extensions import Self
 
 from pydantic import BaseModel, Field, model_validator, field_validator, UUID4, PrivateAttr
 from pydantic_core import PydanticCustomError
 
 from composio import ComposioToolSet
-from composio_langchain import action
 
 from versionhq.tool.composio_tool_vars import ComposioAppName, ComposioAuthScheme, composio_app_set, ComposioStatus, ComposioAction
 from versionhq.tool.cache_handler import CacheHandler

{versionhq-1.2.1.15.dist-info → versionhq-1.2.1.17.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: versionhq
-Version: 1.2.1.15
+Version: 1.2.1.17
 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.15.dist-info → versionhq-1.2.1.17.dist-info}/RECORD

@@ -1,4 +1,4 @@
-versionhq/__init__.py,sha256=v49Zr8uA1uDecJ9sdBDmFy0oknWouJm4rn2oWP6QMQ8,2883
+versionhq/__init__.py,sha256=nNrMhlfHaW9xgRJhnU9sHM4p9c5dL1n0UeAlVkTxwY4,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
@@ -6,14 +6,15 @@ versionhq/_utils/process_config.py,sha256=jbPGXK2Kb4iyCugJ3FwRJuU0wL5Trq2x4xFQz2
 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=snDtgDmvZB2bZKH_RTcz5uFOMl3MTjLJwTQBebFt8hk,2532
-versionhq/agent/model.py,sha256=eFmkNuCJhXRhdYJR59J5PFxw5aghLvBrPRj4NXd7J0w,25873
+versionhq/agent/inhouse_agents.py,sha256=vupO1viYqVb7sKohIE1zThu6JArhh5JLo5LBeSnh0kM,2534
+versionhq/agent/model.py,sha256=ixfYjUY8u6CAFGuaExV8cU1WFlBgNQPxr1UQuxPBSew,25604
 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=nGUVX8Ljiq2mQ5BNXm17SP-kuCRCA87CucRy-QB-Zv0,7426
+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,25 +45,24 @@ 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=EcUW7nktGBd9CBenKLh-5HBRa02wrwYF6WeF8ju04tc,28538
+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
 versionhq/task_graph/colors.py,sha256=naJCx4Vho4iuJtbW8USUXb-M5uYvd5ds2p8qbjUfRus,669
-versionhq/task_graph/draft.py,sha256=gTEICHEoUwlka6TDc9Kw0pKnhdrKtNw5HKhkl9gjIYk,5128
+versionhq/task_graph/draft.py,sha256=AuQ2X-T5xuQ2ipMiAqeh9Pjm6I2fIf952pBQRYqdaog,5131
 versionhq/task_graph/model.py,sha256=njyHQyHrVTZP46iVkC6YvuMnGcS40vOy1wszRtf7DHY,23971
 versionhq/tool/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/tool/cache_handler.py,sha256=iL8FH7X0G-cdT0uhJwzuhLDaadTXOdfybZcDy151-es,1085
-versionhq/tool/composio_tool.py,sha256=38mEiVvTkuw1BLD233Bl1Gwxbpss1yfQiZLTWwX6BdA,8648
+versionhq/tool/composio_tool.py,sha256=IATfsEnF_1RPJyGtPBmAtEJh5XPcgDHpyG3SUR461Og,8572
 versionhq/tool/composio_tool_vars.py,sha256=FvBuEXsOQUYnN7RTFxT20kAkiEYkxWKkiVtgpqOzKZQ,1843
 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.15.dist-info/LICENSE,sha256=cRoGGdM73IiDs6nDWKqPlgSv7aR4n-qBXYnJlCMHCeE,1082
-versionhq-1.2.1.15.dist-info/METADATA,sha256=bmi_7y_zYR9MIDpsD23IfdAGJ8YYs-ifo4xE1CJOFSE,22033
-versionhq-1.2.1.15.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-versionhq-1.2.1.15.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
-versionhq-1.2.1.15.dist-info/RECORD,,
+versionhq-1.2.1.17.dist-info/LICENSE,sha256=cRoGGdM73IiDs6nDWKqPlgSv7aR4n-qBXYnJlCMHCeE,1082
+versionhq-1.2.1.17.dist-info/METADATA,sha256=WenkpMZmDc-5XW_iq-8ksRqp3YTvXzAbr5sjEfw09BQ,22033
+versionhq-1.2.1.17.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+versionhq-1.2.1.17.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
+versionhq-1.2.1.17.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