versionhq 1.2.1.16__tar.gz → 1.2.1.18__tar.gz

{versionhq-1.2.1.16 → versionhq-1.2.1.18}/PKG-INFO

@@ -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 → versionhq-1.2.1.18}/docs/core/agent/ref.md

@@ -17,7 +17,7 @@
 | **`use_developer_prompt`** |  bool | True | - | Whether to use the system (developer) prompt when calling the model. |
 | **`developer_promt_template`** | str | None | True | File path to the prompt template. |
 | **`user_promt_template`** | str | None | True | File path to the prompt template. |
-| **`network`** | [List[Any]] | None | True | Stores a list of agent networks that the agent belongs to. |
+| **`networks`** | List[Any] | list() | True | Stores a list of agent networks that the agent belongs to. |
 | **`allow_delegation`** | bool | False | - | Whether the agent can delegate assinged tasks to another agent. |
 | **`max_retry_limit`** | int | 2 | - | Maximum number of retries when the task execution failed. |
 | **`maxit`** | int | 25 | - | Maximum number of total optimization loops conducted when an error occues during the task execution. |

versionhq-1.2.1.18/docs/core/agent-network/index.md

@@ -0,0 +1,43 @@
+---
+tags:
+  - Agent Network
+---
+
+# Agent Network
+
+<class>`class` versionhq.agent_network.model.<bold>AgentNetwork<bold></class>
+
+A Pydantic class to store `AgentNetwork` objects that handle multiple agent formations for the task execution.
+
+You can specify a desired formation or allow the agents to determine it autonomously (default).
+
+|  | **Solo Agent** | **Supervising** | **Squad** | **Random** |
+| :--- | :--- | :--- | :--- | :--- |
+| **Formation** | <img src="https://res.cloudinary.com/dfeirxlea/image/upload/v1738818211/pj_m_agents/rbgxttfoeqqis1ettlfz.png" alt="solo" width="200"> | <img src="https://res.cloudinary.com/dfeirxlea/image/upload/v1738818211/pj_m_agents/zhungor3elxzer5dum10.png" alt="solo" width="200"> | <img src="https://res.cloudinary.com/dfeirxlea/image/upload/v1738818211/pj_m_agents/dnusl7iy7kiwkxwlpmg8.png" alt="solo" width="200"> | <img src="https://res.cloudinary.com/dfeirxlea/image/upload/v1738818211/pj_m_agents/sndpczatfzbrosxz9ama.png" alt="solo" width="200"> |
+| **Usage** | <ul><li>A single agent with tools, knowledge, and memory.</li><li>When self-learning mode is on - it will turn into **Random** formation.</li></ul> | <ul><li>Leader agent gives directions, while sharing its knowledge and memory.</li><li>Subordinates can be solo agents or networks.</li></ul> | <ul><li>Share tasks, knowledge, and memory among network members.</li></ul> | <ul><li>A single agent handles tasks, asking help from other agents without sharing its memory or knowledge.</li></ul> |
+| **Use case** | An email agent drafts promo message for the given audience. | The leader agent strategizes an outbound campaign plan and assigns components such as media mix or message creation to subordinate agents. | An email agent and social media agent share the product knowledge and deploy multi-channel outbound campaign. | 1. An email agent drafts promo message for the given audience, asking insights on tones from other email agents which oversee other clusters. 2. An agent calls the external agent to deploy the campaign. |
+
+<hr>
+
+## Quick Start
+
+By default, lead agents will determine the best network formation autonomously based on the given task and its goal.
+
+Calling `.launch()` method can start executing tasks by the network, then generate a response in text and JSON formats stored in the `TaskOutput` object.
+
+```python
+import versionhq as vhq
+
+network = vhq.form_agent_network(
+  task=f"create a promo plan to attract a client",
+  expected_outcome='media mix, key messages, and CTA targets.'
+)
+
+res = network.launch()
+
+assert isinstance(res, vhq.TaskOutput)
+```
+
+Ref. <a href="/core/task-output">TaskOutput</a> class
+
+Visit <a href="https://versi0n.io">Playground</a>.

{versionhq-1.2.1.16 → versionhq-1.2.1.18}/docs/core/tool.md

@@ -1,6 +1,6 @@
 ---
 tags:
-  - Utils
+  - Utilities
 ---
 
 # Tool

{versionhq-1.2.1.16 → versionhq-1.2.1.18}/docs/quickstart.md

@@ -2,9 +2,9 @@
 
 ## Package installation
 
-   ```
-   pip install versionhq
-   ```
+```
+pip install versionhq
+```
 
 (Python 3.11, 3.12)
 
@@ -16,15 +16,15 @@ You can generate a network of multiple agents depending on your task complexity.
 
 Here is a code snippet:
 
-   ```python
-   import versionhq as vhq
+```python
+import versionhq as vhq
 
-   network = vhq.form_agent_network(
-      task="YOUR AMAZING TASK OVERVIEW",
-      expected_outcome="YOUR OUTCOME EXPECTATION",
-   )
-   res = network.launch()
-   ```
+network = vhq.form_agent_network(
+   task="YOUR AMAZING TASK OVERVIEW",
+   expected_outcome="YOUR OUTCOME EXPECTATION",
+)
+res = network.launch()
+```
 
 This will form a network with multiple agents on `Formation` and return results as a `TaskOutput` object, storing outputs in JSON, plane text, Pydantic model formats along with evaluation.
 
@@ -36,44 +36,45 @@ If you don't need to form a network or assign a specific agent to the network, y
 Agents can execute tasks using `Task` model and return JSON format by default with plane text and pydantic model formats as options.
 
 
-   ```python
-   import versionhq as vhq
-   from pydantic import BaseModel
+```python
+import versionhq as vhq
+from pydantic import BaseModel
+
+class CustomOutput(BaseModel):
+   test1: str
+   test2: list[str]
 
-   class CustomOutput(BaseModel):
-      test1: str
-      test2: list[str]
+def dummy_func(message: str, test1: str, test2: list[str]) -> str:
+   return f"""{message}: {test1}, {", ".join(test2)}"""
 
-   def dummy_func(message: str, test1: str, test2: list[str]) -> str:
-      return f"""{message}: {test1}, {", ".join(test2)}"""
 
+agent = vhq.Agent(role="demo", goal="amazing project goal")
 
-   agent = vhq.Agent(role="demo", goal="amazing project goal")
+task = vhq.Task(
+   description="Amazing task",
+   pydantic_output=CustomOutput,
+   callback=dummy_func,
+   callback_kwargs=dict(message="Hi! Here is the result: ")
+)
 
-   task = vhq.Task(
-      description="Amazing task",
-      pydantic_output=CustomOutput,
-      callback=dummy_func,
-      callback_kwargs=dict(message="Hi! Here is the result: ")
-   )
+res = task.execute(agent=agent, context="amazing context to consider.")
 
-   res = task.execute(agent=agent, context="amazing context to consider.")
-   print(res)
-   ```
+assert isinstance(res, vhq.TaskOutput)
+```
 
 This will return a `TaskOutput` object that stores response in plane text, JSON, and Pydantic model: `CustomOutput` formats with a callback result, tool output (if given), and evaluation results (if given).
 
-   ```python
-   res == TaskOutput(
-      task_id=UUID('<TASK UUID>'),
-      raw='{\"test1\":\"random str\", \"test2\":[\"str item 1\", \"str item 2\", \"str item 3\"]}',
-      json_dict={'test1': 'random str', 'test2': ['str item 1', 'str item 2', 'str item 3']},
-      pydantic=<class '__main__.CustomOutput'>,
-      tool_output=None,
-      callback_output='Hi! Here is the result: random str, str item 1, str item 2, str item 3', # returned a plain text summary
-      evaluation=None
-   )
-   ```
+```python
+res == TaskOutput(
+   task_id=UUID('<TASK UUID>'),
+   raw='{\"test1\":\"random str\", \"test2\":[\"str item 1\", \"str item 2\", \"str item 3\"]}',
+   json_dict={'test1': 'random str', 'test2': ['str item 1', 'str item 2', 'str item 3']},
+   pydantic=<class '__main__.CustomOutput'>,
+   tool_output=None,
+   callback_output='Hi! Here is the result: random str, str item 1, str item 2, str item 3', # returned a plain text summary
+   evaluation=None
+)
+```
 
 ## Supervising
 
@@ -106,8 +107,8 @@ network =vhq.AgentNetwork(
 res = network.launch()
 
 assert isinstance(res, vhq.NetworkOutput)
-assert not [item for item in task_1.processed_agents if "vhq-Delegated-Agent" == item]
-assert [item for item in task_1.processed_agents if "agent b" == item]
+assert "agent b" in task_1.processed_agents # agent_b delegated by agent_a
+assert "agent b" in task_2.processed_agents
 ```
 
 This will return a list with dictionaries with keys defined in the `ResponseField` of each task.

{versionhq-1.2.1.16 → versionhq-1.2.1.18}/mkdocs.yml

@@ -110,7 +110,8 @@ theme:
 nav:
   - Home: 'index.md'
   - Quick Start: 'quickstart.md'
-  - Core:
+  - Agent Network:
+    - 'core/agent-network/index.md'
     - Agent:
       - 'core/agent/index.md'
       - Configuration: 'core/agent/config.md'
@@ -118,15 +119,16 @@ nav:
       - Reference: 'core/agent/ref.md'
     - LLM:
       - 'core/llm/index.md'
-    - Task Graph:
-      - 'core/task-graph/index.md'
+  - Task Graph:
+    - 'core/task-graph/index.md'
     - Task:
       - 'core/task/index.md'
       - TaskOutput: 'core/task/task-output.md'
       - ResponseField: 'core/task/response-field.md'
       - Evaluation: 'core/task/evaluation.md'
+  - Components:
     - Tool: 'core/tool.md'
-  - Tags: 'tags.md'
+  - Archive: 'tags.md'
   - Cases:
     - Playground: https://versi0n.io/playground
     - Experiment - Agent Performance: https://github.com/versionHQ/exp-agent-performance

{versionhq-1.2.1.16 → versionhq-1.2.1.18}/pyproject.toml

@@ -15,7 +15,7 @@ exclude = ["test*", "__pycache__", "*.egg-info"]
 
 [project]
 name = "versionhq"
-version = "1.2.1.16"
+version = "1.2.1.18"
 authors = [{ name = "Kuriko Iwai", email = "kuriko@versi0n.io" }]
 description = "An agentic orchestration framework for building agent networks that handle task automation."
 readme = "README.md"

{versionhq-1.2.1.16 → versionhq-1.2.1.18}/src/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-1.2.1.16 → versionhq-1.2.1.18}/src/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-1.2.1.16 → versionhq-1.2.1.18}/src/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-1.2.1.18/src/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