versionhq 1.2.1.5__py3-none-any.whl → 1.2.1.6__py3-none-any.whl

versionhq/__init__.py

@@ -28,9 +28,10 @@ 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.task_graph.draft import workflow
 
 
-__version__ = "1.2.1.5"
+__version__ = "1.2.1.6"
 __all__ = [
     "Agent",
 
@@ -88,5 +89,6 @@ __all__ = [
     "UserMemory",
     "MemoryItem",
 
-    "form_agent_network"
+    "form_agent_network",
+    "workflow",
 ]

versionhq/task/formation.py

@@ -39,7 +39,7 @@ def form_agent_network(
                         pass
 
                 case str():
-                    matched = [item for item in Formation._member_names_ if item == formation.upper()]
+                    matched = [item for item in Formation.s_ if item == formation.upper()]
                     if matched:
                         formation = getattr(Formation, matched[0])
                     else:

versionhq/task/model.py

@@ -4,6 +4,7 @@ import datetime
 import uuid
 import inspect
 import enum
+from textwrap import dedent
 from concurrent.futures import Future
 from hashlib import md5
 from typing import Any, Dict, List, Set, Optional, Callable, Type
@@ -288,7 +289,7 @@ class Task(BaseModel):
     should_evaluate: bool = Field(default=False, description="True to run the evaluation flow")
     eval_criteria: Optional[List[str]] = Field(default_factory=list, description="criteria to evaluate the outcome. i.e., fit to the brand tone")
 
-    # recording
+    # recording !# REFINEME - eval_callbacks
     processed_agents: Set[str] = Field(default_factory=set, description="store roles of the agents that executed the task")
     tool_errors: int = 0
     delegations: int = 0
@@ -364,7 +365,7 @@ Ref. Output image: {output_formats_to_follow}
         else:
             output_prompt = "Return your response as a valid JSON serializable string, enclosed in double quotes. Do not use single quotes, trailing commas, or other non-standard JSON syntax."
 
-        return output_prompt
+        return dedent(output_prompt)
 
 
     def _draft_context_prompt(self, context: Any) -> str:
@@ -374,7 +375,7 @@ Ref. Output image: {output_formats_to_follow}
 
         context_to_add = None
         if not context:
-            Logger().log(level="error", color="red", message="Missing a context to add to the prompt. We'll return ''.")
+            # Logger().log(level="error", color="red", message="Missing a context to add to the prompt. We'll return ''.")
             return context_to_add
 
         match context:
@@ -403,7 +404,7 @@ Ref. Output image: {output_formats_to_follow}
             case _:
                 pass
 
-        return context_to_add
+        return dedent(context_to_add)
 
 
     def _prompt(self, model_provider: str = None, context: Optional[Any] = None) -> str:
@@ -593,7 +594,6 @@ Ref. Output image: {output_formats_to_follow}
                 return self._execute_async(agent=agent, context=context)
 
 
-
     def _execute_sync(self, agent, context: Optional[Any] = None) -> TaskOutput:
         """Executes the task synchronously."""
         return self._execute_core(agent, context)

versionhq/task_graph/colors.py

@@ -0,0 +1,28 @@
+white = "#fafafa"
+black = "#191b1b"
+darkgrey = "#363636"
+grey = "#414141"
+primary = "#B9005B"
+orange = "#ffb713"
+lightgreen = "#b8fff5"
+green = "#00d1b2"
+darkgreen = "#169d87"
+darkergreen = "#026b5d"
+
+
+# $black: #191b1b;
+# $true-white: #ffffff;
+# $white: #fafafa;
+# $grey: #414141;
+# $light-grey: #f9f9f9;
+# $border-color: #dedede;
+# $primary: #B9005B;
+# $primary-hovered: #9D034F;
+# $gradient-main: linear-gradient(to right $black $primary);
+# $linkedin-blue: #0077B5;
+# $bulma-primary: #00d1b2;
+# $bluma-primary-dark: #169d87;
+# $bulma-grey-light: hsl(0 0%, 71%);
+# $bulma-grey: hsl(0, 0%, 48%);
+# $bulma-dark: hsl(0, 0%, 21%); //#363636
+# $bulma-white-ter: #F5F5F5;

versionhq/task_graph/draft.py

@@ -0,0 +1,101 @@
+import sys
+from typing import Type, Any
+from pydantic import BaseModel
+from pydantic._internal._model_construction import ModelMetaclass
+from textwrap import dedent
+if 'pydantic.main' not in sys.modules:
+    import pydantic.main
+
+sys.modules['pydantic.main'].ModelMetaclass = ModelMetaclass
+
+from versionhq.agent.model import Agent
+from versionhq.task.model import ResponseField
+from versionhq.task_graph.model import TaskGraph, Task, DependencyType, Node, TaskStatus
+from versionhq._utils.logger import Logger
+
+
+def workflow(final_output: Type[BaseModel], context: Any = None, human: bool = True) -> TaskGraph | None:
+    """
+    Generate a TaskGraph object to generate the givne final_output most resource-efficiently.
+    """
+
+    if not final_output or not isinstance(final_output, ModelMetaclass):
+        Logger().log(level="error", message="Missing an expected output in Pydantic model.", color="red")
+        return None
+
+    final_output_prompt = ", ".join([k for k in final_output.model_fields.keys()])
+
+    if not final_output_prompt:
+        Logger().log(level="error", message="Expected output is in invalid format.", color="red")
+        return None
+
+    context_prompt = f'We are designing a resource-efficient workflow using graph algorithm concepts to achieve the following goal: {final_output_prompt}.'
+
+    dep_type_prompt = ", ".join([k for k in DependencyType._member_map_.keys()])
+
+    graph_expert = Agent(
+        role="vhq-G Expert",
+        goal="design the most resource-efficient workflow graph to achieve the given goal",
+        knowledge_sources=[
+            "https://en.wikipedia.org/wiki/Graph_theory",
+            # "https://www.geeksforgeeks.org/graph-data-structure-and-algorithms/?ref=lbp",
+            "https://www.geeksforgeeks.org/graph-and-its-representations/",
+            ", ".join([k for k in DependencyType._member_map_.keys()]),
+        ],
+        llm="gemini-2.0",
+        use_memory=True,
+        maxit=1,
+        max_retry_limit=1,
+    )
+
+    task = Task(
+        description=f"Design a resource-efficient workflow to achieve the following goal: {final_output_prompt}.  The workflow should consist of a list of tasks, each with the following information:\nname: A concise name of the task\ndescription: A concise description of the task.\nconnections: A list of target tasks that this task connects to.\ndependency_types: The type of dependency between this task and each of its connected task. Use the following dependency types: {dep_type_prompt}.\n\nPrioritize minimizing resource consumption (computation, memory, and data transfer) when defining tasks, connections, and dependencies.  Consider how data is passed between tasks and aim to reduce unnecessary data duplication or transfer.  Explain any design choices made to optimize resource usage.",
+        response_fields=[
+            ResponseField(title="tasks", data_type=list, items=dict, properties=[
+                    ResponseField(title="name", data_type=str),
+                    ResponseField(title="description", data_type=str),
+                    ResponseField(title="connections", data_type=list, items=str),
+                    ResponseField(title="dependency_types", data_type=list, items=str),
+                ]
+            )
+        ]
+    )
+    res = task.execute(agent=graph_expert, context=[context_prompt, context])
+
+    if not res:
+        return None
+
+    task_items = res.json_dict["tasks"]
+    tasks = [Task(name=item["name"], description=item["description"]) for item in task_items]
+    nodes = [Node(task=task) for task in tasks]
+    task_graph = TaskGraph(
+        nodes={node.identifier: node for node in nodes},
+        concl=final_output,
+        should_reform=True,
+    )
+
+    for res in task_items:
+        if res["connections"]:
+            dependency_types = [DependencyType[dt] if DependencyType[dt] else DependencyType.FINISH_TO_START for dt in res["dependency_types"]]
+
+            for i, target_task_name in enumerate(res["connections"]):
+                source = [v for k, v in task_graph.nodes.items() if v.task.name == res["name"]][0]
+                target = [v for k, v in task_graph.nodes.items() if v.task.name == target_task_name][0]
+                dependency_type = dependency_types[i]
+                task_graph.add_dependency(source_node_identifier=source.identifier, target_node_identifier=target.identifier, dependency_type=dependency_type)
+
+    ## test purpose
+    # task_graph.visualize()
+
+    # if human:
+    #     print('Proceed? Y/n:')
+    #     x = input()
+
+    #     if x.lower() == "y":
+    #         print("ok. generating agent network")
+
+    #     else:
+    #         request = input("request?")
+    #         print('ok. regenerating the graph based on your input: ', request)
+
+    return task_graph

versionhq/task_graph/model.py

@@ -4,8 +4,9 @@ import networkx as nx
 import matplotlib.pyplot as plt
 from abc import ABC
 from typing import List, Any, Optional, Callable, Dict, Type, Tuple
+from typing_extensions import Self
 
-from pydantic import BaseModel, InstanceOf, Field, UUID4, field_validator
+from pydantic import BaseModel, InstanceOf, Field, UUID4, field_validator, model_validator
 from pydantic_core import PydanticCustomError
 
 from versionhq.task.model import Task, TaskOutput
@@ -36,32 +37,13 @@ class DependencyType(enum.Enum):
     START_TO_FINISH = "SF"  # Task B finishes when Task A starts
 
 
-
-# class TriggerEvent(enum.Enum):
-#     """
-#     Concise enumeration of key trigger events for task execution.
-#     """
-#     IMMEDIATE = 0 # execute immediately
-#     DEPENDENCIES_MET = 1  # All/required dependencies are satisfied
-#     RESOURCES_AVAILABLE = 2  # Necessary resources are available
-#     SCHEDULED_TIME = 3  # Scheduled start time or time window reached
-#     EXTERNAL_EVENT = 4  # Triggered by an external event/message
-#     DATA_AVAILABLE = 5  # Required data  is available both internal/external
-#     APPROVAL_RECEIVED = 6  # Necessary approvals have been granted
-#     STATUS_CHANGED = 7  # Relevant task/system status has changed
-#     RULE_MET = 8  # A predefined rule or condition has been met
-#     MANUAL_TRIGGER = 9  # Manually initiated by a user
-#     ERROR_HANDLED = 10  # A previous error/exception has been handled
-
-
-
 class Node(BaseModel):
     """
     A class to store a node object.
     """
+
     id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
     task: InstanceOf[Task] = Field(default=None)
-    # trigger_event: TriggerEvent = Field(default=TriggerEvent.IMMEDIATE, description="store trigger event for starting the task execution")
     in_degree_nodes: List[Any] = Field(default_factory=list, description="list of Node objects")
     out_degree_nodes: List[Any] = Field(default_factory=list, description="list of Node objects")
     assigned_to: InstanceOf[Agent] = Field(default=None)
@@ -70,14 +52,14 @@ class Node(BaseModel):
 
     @field_validator("id", mode="before")
     @classmethod
-    def _deny_id(cls, v: Optional[UUID4]) -> None:
+    def _deny_user_set_id(cls, v: Optional[UUID4]) -> None:
         if v:
-            raise PydanticCustomError("may_not_set_field", "This field is not to be set by the user.", {})
+            raise PydanticCustomError("may_not_set_field", "This field is not to be set by client.", {})
+
 
     def is_independent(self) -> bool:
         return not self.in_degree_nodes and not self.out_degree_nodes
 
-
     def handle_task_execution(self, agent: Agent = None, context: str = None) -> TaskOutput | None:
         """
         Start task execution and update status accordingly.
@@ -109,11 +91,14 @@ class Node(BaseModel):
 
     @property
     def identifier(self) -> str:
-        """Unique identifier for the node"""
+        """Unique identifier of the node"""
         return f"{str(self.id)}"
 
     def __str__(self):
-        return self.identifier
+        if self.task:
+            return f"{self.identifier}: {self.task.name if self.task.name else self.task.description[0: 12]}"
+        else:
+            return self.identifier
 
 
 class Edge(BaseModel):
@@ -136,6 +121,17 @@ class Edge(BaseModel):
     data_transfer: bool = Field(default=True, description="whether the data transfer is required. by default transfer plane text output from in-degree nodes as context")
 
 
+    def _response_schema(self) -> Type[BaseModel]:
+        class EdgeResponseSchema(BaseModel):
+            wight: float
+            dependecy_type: str
+            required: bool
+            need_condition: bool
+            lag_in_sec: float
+
+        return EdgeResponseSchema
+
+
     def dependency_met(self) -> bool:
         """
         Defines if the dependency is ready to execute:
@@ -153,28 +149,28 @@ class Edge(BaseModel):
         match self.dependency_type:
             case DependencyType.FINISH_TO_START:
                 """target starts after source finishes"""
-                if self.source.status == TaskStatus.COMPLETED:
+                if not self.source or self.source.status == TaskStatus.COMPLETED:
                     return self.condition(**self.conditon_kwargs) if self.condition else True
                 else:
                     return False
 
             case DependencyType.START_TO_START:
                 """target starts when source starts"""
-                if self.source.status != TaskStatus.NOT_STARTED:
+                if not self.source or self.source.status != TaskStatus.NOT_STARTED:
                     return self.condition(**self.conditon_kwargs) if self.condition else True
                 else:
                     return False
 
             case DependencyType.FINISH_TO_FINISH:
                 """target finish when source start"""
-                if self.source.status != TaskStatus.COMPLETED:
+                if not self.source or self.source.status != TaskStatus.COMPLETED:
                     return self.condition(**self.conditon_kwargs) if self.condition else True
                 else:
                     return False
 
             case DependencyType.START_TO_FINISH:
                 """target finishes when source start"""
-                if self.source.status == TaskStatus.IN_PROGRESS:
+                if not self.source or self.source.status == TaskStatus.IN_PROGRESS:
                     return self.condition(**self.conditon_kwargs) if self.condition else True
                 else:
                     return False
@@ -190,10 +186,9 @@ class Edge(BaseModel):
             return None
 
         if not self.dependency_met():
-            Logger(verbose=True).log(level="warning", message="Dependencies not met. We'll see the source node status.", color="yellow")
+            Logger(verbose=True).log(level="warning", message="Dependencies not met. We'll return None.", color="yellow")
             return None
 
-
         if self.lag:
             import time
             time.sleep(self.lag)
@@ -207,29 +202,42 @@ class Graph(ABC, BaseModel):
     """
     An abstract class to store G using NetworkX library.
     """
-
     directed: bool = Field(default=False, description="Whether the graph is directed")
     graph: Type[nx.Graph] = Field(default=None)
-    nodes: Dict[str, InstanceOf[Node]] = Field(default_factory=dict, description="identifier: Node - for the sake of ")
-    edges: Dict[str, InstanceOf[Edge]] = Field(default_factory=dict)
+    nodes: Dict[str, Node] = Field(default_factory=dict, description="identifier: Node - for the sake of ")
+    edges: Dict[str, Edge] = Field(default_factory=dict)
 
     def __init__(self, directed: bool = False, **kwargs):
         super().__init__(directed=directed, **kwargs)
-        self.graph = nx.DiGraph() if self.directed else nx.Graph()
+        self.graph = nx.DiGraph(directed=True) if self.directed else nx.Graph()
+
 
     def _return_node_object(self, node_identifier) -> Node | None:
-        return [v for k, v in self.nodes.items() if k == node_identifier][0] if [v for k, v in self.nodes.items() if k == node_identifier] else None
+        match = [v for k, v in self.nodes.items() if k == node_identifier]
+
+        if match:
+            node = match[0] if isinstance(match[0], Node) else match[0]["node"] if "node" in match[0] else None
+            return node
+        else:
+            return None
 
     def add_node(self, node: Node) -> None:
-        self.graph.add_node(node.identifier, **node.model_dump())
+        if node.identifier in self.nodes.keys():
+            return
+        self.graph.add_node(node.identifier, node=node)
         self.nodes[node.identifier] = node
 
     def add_edge(self, source: str, target: str, edge: Edge) -> None:
-        self.graph.add_edge(source, target, **edge.model_dump())
-        edge.source = self._return_node_object(source)
-        edge.source.out_degree_nodes.append(target)
-        edge.target = self._return_node_object(target)
-        edge.target.in_degree_nodes.append(source)
+        self.graph.add_edge(source, target, edge=edge)
+
+        source_node, target_node = self._return_node_object(source), self._return_node_object(target)
+
+        edge.source = source_node
+        source_node.out_degree_nodes.append(target_node)
+
+        edge.target = target_node
+        target_node.in_degree_nodes.append(source_node)
+
         self.edges[(source, target)] = edge
 
     def add_weighted_edges_from(self, edges):
@@ -244,11 +252,11 @@ class Graph(ABC, BaseModel):
     def get_out_degree(self, node: Node) -> int:
         return self.graph.out_degree(node)
 
-    def find_start_nodes(self) -> Tuple[Node]:
-        return [v for k, v in self.nodes.items() if v.in_degrees == 0 and v.out_degrees > 0]
+    def find_start_nodes(self) -> List[Node]:
+        return [v for v in self.nodes.values() if v.in_degrees == 0 and v.out_degrees > 0]
 
-    def find_end_nodes(self) ->  Tuple[Node]:
-        return [v for k, v in self.nodes.items() if v.out_degrees == 0 and v.in_degrees > 0]
+    def find_end_nodes(self) ->  List[Node]:
+        return [v for v in self.nodes.values() if v.out_degrees == 0 and v.in_degrees > 0]
 
     def find_critical_end_node(self) -> Node | None:
         """
@@ -310,51 +318,26 @@ class Graph(ABC, BaseModel):
             return False
 
 
-    def visualize(self, title: str = "Task Graph", pos: Any = None, **graph_config):
-        pos = pos if pos else nx.spring_layout(self.graph, seed=42)
-        nx.draw(
-            self.graph,
-            pos,
-            with_labels=True, node_size=700, node_color="skyblue", font_size=10, font_color="black", arrowstyle='-|>', arrowsize=20, arrows=True,
-            **graph_config
-        )
-        edge_labels = {}
-        for u, v, data in self.graph.edges(data=True):
-            edge = self.edges.get((u,v))
-            if edge:
-                label_parts = []
-                if edge.type:
-                    label_parts.append(f"Type: {edge.type}")
-                if edge.duration is not None:
-                    label_parts.append(f"Duration: {edge.duration}")
-                if edge.lag is not None:
-                    label_parts.append(f"Lag: {edge.lag}")
-                edge_labels[(u, v)] = "\n".join(label_parts)  # Combine labels with newlines
-        nx.draw_networkx_edge_labels(self.graph, pos, edge_labels=edge_labels)
-        plt.title(title)
-        plt.show()
-
-
 class TaskGraph(Graph):
     id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
     should_reform: bool = Field(default=False)
-    status: Dict[str, TaskStatus] = Field(default_factory=dict, description="store identifier (str) and TaskStatus of all task_nodes")
-    outputs: Dict[str, TaskOutput] = Field(default_factory=dict, description="store node identifire and TaskOutput")
-    conclusion: Any = Field(default=None, description="store the final result of the entire task graph. critical path target/end node")
+    outputs: Dict[str, TaskOutput] = Field(default_factory=dict, description="stores node identifier and TaskOutput")
+    concl_template: Optional[Dict[str, Any] | Type[BaseModel]] = Field(default=None, description="stores a format of `concl` either in Pydantic model or JSON dict")
+    concl: Any = Field(default=None, description="store the final result of the entire task graph")
 
 
-    def _save(self, abs_file_path: str = None) -> None:
+    def _save(self, title: str, abs_file_path: str = None) -> None:
         """
         Save the graph image in the local directory.
         """
-
         try:
             import os
             project_root = os.path.abspath(os.getcwd())
-            abs_file_path = abs_file_path if abs_file_path else f"{project_root}/uploads"
+            abs_file_path = abs_file_path if abs_file_path else f"{project_root}/.diagrams"
+            title = title if title else f"vhq-Diagram-{str(self.id)}"
 
             os.makedirs(abs_file_path, exist_ok=True)
-            plt.savefig(f"{abs_file_path}/{str(self.id)}.png")
+            plt.savefig(f"{abs_file_path}/{title}.png")
 
         except Exception as e:
             Logger().log(level="error", message=f"Failed to save the graph {str(self.id)}: {str(e)}", color="red")
@@ -362,21 +345,38 @@ class TaskGraph(Graph):
 
     def add_task(self, task: Node | Task) -> Node:
         """Convert `task` to a Node object and add it to G"""
-        task_node = task if isinstance(task, Node) else Node(task=task)
-        self.add_node(task_node)
-        self.status[task_node.identifier] = TaskStatus.NOT_STARTED
-        return task_node
 
+        if isinstance(task, Node) and task.identifier in self.nodes.keys():
+            return task
+
+        elif isinstance(task, Task):
+            match = []
+            for v in self.nodes.values():
+                if type(v) == dict and v["node"] and v["node"].task == task:
+                    match.append(v["node"])
+                elif v.task == task:
+                    match.append(v)
 
-    def add_dependency(
-            self, source_task_node_identifier: str, target_task_node_identifier: str, **edge_attributes
-        ) -> None:
+            if match:
+                return match[0]
+            else:
+                node = Node(task=task)
+                self.add_node(node)
+                return node
+
+        else:
+            task_node = task if isinstance(task, Node) else Node(task=task)
+            self.add_node(task_node)
+            return task_node
+
+
+    def add_dependency(self, source_node_identifier: str, target_node_identifier: str, **edge_attributes) -> None:
         """
         Add an edge that connect task 1 (source) and task 2 (target) using task_node.name as an identifier
         """
 
         if not edge_attributes:
-            Logger(verbose=True).log(level="error", message="Edge attributes are missing.", color="red")
+            Logger().log(level="error", message="Edge attributes are missing.", color="red")
 
         edge = Edge()
         for k in Edge.model_fields.keys():
@@ -386,78 +386,97 @@ class TaskGraph(Graph):
             else:
                 pass
 
-        self.add_edge(source_task_node_identifier, target_task_node_identifier, edge)
-
-
-    def set_task_status(self, identifier: str, status: TaskStatus) -> None:
-        if identifier in self.status:
-            self.status[identifier] = status
-        else:
-            Logger().log(level="warning", message=f"Task '{identifier}' not found in the graph.", color="yellow")
-            pass
+        self.add_edge(source_node_identifier, target_node_identifier, edge)
 
 
-    def get_task_status(self, identifier):
-        if identifier in self.status:
-            return self.status[identifier]
-        else:
-            Logger().log(level="warning", message=f"Task '{identifier}' not found in the graph.", color="yellow")
+    def get_task_status(self, identifier: str) -> TaskStatus | None:
+        """Retrieves the latest status of the given node"""
+        if not identifier or identifier not in self.nodes.keys():
+            Logger().log(level="error", message=f"Task node: {identifier} is not in the graph.", color="red")
             return None
 
+        return self._return_node_object(identifier).status
+
 
     def visualize(self, layout: str = None):
+        from matplotlib.lines import Line2D
+        from versionhq.task_graph.colors import white, black, darkgrey, grey, primary, orange, lightgreen, green, darkgreen, darkergreen
+
         try:
             pos = nx.drawing.nx_agraph.graphviz_layout(self.graph, prog='dot') # 'dot', 'neato', 'fdp', 'sfdp'
         except ImportError:
             pos = nx.spring_layout(self.graph, seed=42) # REFINEME - layout
 
-        node_colors = list()
-        for k, v in self.graph.nodes.items():
+        node_colors, legend_elements = list(), list()
+        for k, v in self.nodes.items():
             status = self.get_task_status(identifier=k)
-            if status == TaskStatus.NOT_STARTED:
-                node_colors.append("skyblue")
-            elif status == TaskStatus.IN_PROGRESS:
-                node_colors.append("lightgreen")
-            elif status == TaskStatus.BLOCKED:
-                node_colors.append("lightcoral")
-            elif status == TaskStatus.COMPLETED:
-                node_colors.append("black")
-            elif status == TaskStatus.DELAYED:
-                node_colors.append("orange")
-            elif status == TaskStatus.ON_HOLD:
-                node_colors.append("yellow")
-            else:
-                node_colors.append("grey")
+            node =  v if isinstance(v, Node) else v["node"] if hasattr(v, "node") else None
+            if node:
+                task_name = node.task.name if node.task and node.task.name else node.task.description if node.task else None
+                legend_label = f"ID {str(node.identifier)[0: 6]}...: {task_name}" if task_name else f"ID {str(node.identifier)[0: 6]}..."
+                match status:
+                    case TaskStatus.NOT_STARTED:
+                        node_colors.append(green)
+                        legend_elements.append(Line2D([0], [0], marker='o', color='w', label=legend_label, markerfacecolor=green))
+
+                    case TaskStatus.IN_PROGRESS:
+                        node_colors.append(darkgreen)
+                        legend_elements.append(Line2D([0], [0], marker='o', color='w', label=legend_label, markerfacecolor=darkgreen))
+
+                    case TaskStatus.WAITING:
+                        node_colors.append(lightgreen)
+                        legend_elements.append(Line2D([0], [0], marker='o', color='w', label=legend_label, markerfacecolor=lightgreen))
+
+                    case TaskStatus.COMPLETED:
+                        node_colors.append(darkergreen)
+                        legend_elements.append(Line2D([0], [0], marker='o', color='w', label=legend_label, markerfacecolor=darkergreen))
+
+                    case TaskStatus.DELAYED:
+                        node_colors.append(orange)
+                        legend_elements.append(Line2D([0], [0], marker='o', color='w', label=legend_label, markerfacecolor=orange))
+
+                    case TaskStatus.ON_HOLD:
+                        node_colors.append(grey)
+                        legend_elements.append(Line2D([0], [0], marker='o', color='w', label=legend_label, markerfacecolor=grey))
+
+                    case TaskStatus.ERROR:
+                        node_colors.append(primary)
+                        legend_elements.append(Line2D([0], [0], marker='o', color='w', label=legend_label, markerfacecolor=primary))
+
+                    case _:
+                        node_colors.append(white)
+                        legend_elements.append(Line2D([0], [0], marker='o', color='w', label=legend_label, markerfacecolor=white))
 
         critical_paths, duration, paths = self.find_critical_path()
-        edge_colors = ['red' if (u, v) in zip(critical_paths, critical_paths[1:]) else 'black' for u, v in self.graph.edges()]
-        edge_widths = []
+        edge_colors = [black if (u, v) in zip(critical_paths, critical_paths[1:]) else darkgrey for u, v in self.graph.edges()]
+        edge_widths = [v.weight * 0.5 for v in self.edges.values()]
 
-        for k, v in self.edges.items():
-            # edge_weights = nx.get_edge_attributes(self.graph, 'weight')
-            # edge_colors.append(plt.cm.viridis(v.weight / max(edge_weights.values())))
-            edge_widths.append(v.weight * 0.5)
+        # for k, v in self.edges.items():
+        #     # edge_weights = nx.get_edge_attributes(self.graph, 'weight')
+        #     # edge_colors.append(plt.cm.viridis(v.weight / max(edge_weights.values())))
+        #     edge_widths.append(v.weight * 0.5)
 
         nx.draw(
             self.graph, pos,
             with_labels=True,
-            node_size=700,
+            node_size=600,
             node_color=node_colors,
-            font_size=10,
-            font_color="black",
+            font_size=8,
+            font_color=darkgrey,
             edge_color=edge_colors,
             width=edge_widths,
             arrows=True,
-            arrowsize=20,
+            arrowsize=15,
             arrowstyle='-|>'
         )
 
         edge_labels = nx.get_edge_attributes(G=self.graph, name="edges")
         nx.draw_networkx_edge_labels(self.graph, pos, edge_labels=edge_labels)
 
-        plt.title("Project Network Diagram")
-        self._save()
-        plt.show()
+        plt.legend(handles=legend_elements, loc='lower right')
+        plt.title(f"vhq-Diagram {str(self.id)}")
+        self._save(title=f"vhq-Diagram {str(self.id)}")
+        plt.show(block=False)
 
 
     def activate(self, target_node_identifier: Optional[str] = None) -> Tuple[TaskOutput | None, Dict[str, TaskOutput]]:
@@ -465,6 +484,9 @@ class TaskGraph(Graph):
         Starts to execute all nodes in the graph or a specific node if the target is given, following the given conditons of the edge obeject.
         Then returns tuple of the last task output and all task outputs (self.outputs)
         """
+
+        Logger().log(color="blue", message=f"Start to activate the graph: {str(self.id)}", level="info")
+
         if target_node_identifier:
             if not [k for k in self.nodes.keys() if k == target_node_identifier]:
                 Logger().log(level="error", message=f"The node {str(target_node_identifier)} is not in the graph.", color="red")
@@ -483,7 +505,6 @@ class TaskGraph(Graph):
             if len([item for item in edge_status if item["dep_met"] == True]) == len(sources):
                 res = node.handle_task_execution()
                 self.outputs.update({ target_node_identifier: res })
-                self.status.update({ target_node_identifier: edge.target.status })
 
             return res, self.outputs
 
@@ -502,15 +523,13 @@ class TaskGraph(Graph):
             if end_nodes and len([node for node in end_nodes if node.status == TaskStatus.COMPLETED]) == len(end_nodes):
                 if critical_end_node:
                     return critical_end_node.task.output, self.outputs
-
                 else:
-                    return [v.task.output.raw for k, v in end_nodes.items()][0], self.outputs
+                    return [v.task.output for k, v in end_nodes.items()][0], self.outputs
 
             # Else, execute nodes connected with the critical_path
             elif critical_path:
                 for item in critical_path:
                     edge = [v for k, v in self.edges.items() if item in k]
-
                     if edge:
                         edge = edge[0]
 
@@ -521,29 +540,24 @@ class TaskGraph(Graph):
                             res = edge.activate()
                             node_identifier = edge.target.identifier
                             self.outputs.update({ node_identifier: res })
-                            self.status.update({ node_identifier: edge.target.status })
 
                             if not res and start_nodes:
                                 for node in start_nodes:
                                     res = node.handle_task_execution()
                                     self.outputs.update({ node.identifier: res })
-                                    self.status.update({ node.identifier: node.status })
 
-            # if no critical paths in the graph, simply start from the start nodes.
+            # If no critical paths in the graph, simply start from the start nodes.
             elif start_nodes:
                 for node in start_nodes:
                     res = node.handle_task_execution()
                     self.outputs.update({ node.identifier: res })
-                    self.status.update({ node.identifier: node.status })
-
 
-            # if none of above is applicable, try to activate all the edges.
+            # If none of above is applicable, try to activate all the edges.
             else:
                 for k, edge in self.edges.items():
                     res = edge.activate()
                     node_identifier = edge.target.identifier
                     self.outputs.update({ node_identifier: res })
-                    self.status.update({ node_identifier: edge.target.status })
 
             # last_task_output = [v for v in self.outputs.values()][len([v for v in self.outputs.values()]) - 1] if [v for v in self.outputs.values()] else None
             return res, self.outputs

{versionhq-1.2.1.5.dist-info → versionhq-1.2.1.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: versionhq
-Version: 1.2.1.5
+Version: 1.2.1.6
 Summary: An agentic orchestration framework for building agent networks that handle task automation.
 Author-email: Kuriko Iwai <kuriko@versi0n.io>
 License: MIT License
@@ -89,7 +89,7 @@ Requires-Dist: pygraphviz>=1.14; extra == "pygraphviz"
 ![pyenv ver](https://img.shields.io/badge/pyenv-2.5.0-orange)
 
 
-Agentic orchestration framework for multi-agent networks and task graph for complex task automation.
+Agentic orchestration framework for multi-agent networks and task graphs for complex task automation.
 
 **Visit:**
 
@@ -361,7 +361,7 @@ Tasks can be delegated to a manager, peers within the agent network, or a comple
 
 **Workflow, Task Graph**
 
-* [NetworkX](https://networkx.org/documentation/stable/reference/introduction.html): A Python package to analyze, create, and manipulate complex graph networks.
+* [NetworkX](https://networkx.org/documentation/stable/reference/introduction.html): A Python package to analyze, create, and manipulate complex graph networks. Ref. [Gallary](https://networkx.org/documentation/latest/auto_examples/index.html)
 * [Matplotlib](https://matplotlib.org/stable/index.html): For graph visualization.
 * [Graphviz](https://graphviz.org/about/): For graph visualization.
 
@@ -397,7 +397,7 @@ Tasks can be delegated to a manager, peers within the agent network, or a comple
 .github
 └── workflows/                # Github actions
 │
-docs/                         # Documentation built by MkDocs
+docs/                         # Documentation
 mkdocs.yml                    # MkDocs config
 │
 src/
@@ -413,12 +413,13 @@ src/
 │     └── llm/
 │     └── ...
 │
-└── uploads/  [.gitignore]    # Local directory to store uploaded files such as graphviz diagrams generatd by `Network` class
+└── .diagrams/  [.gitignore]  # Local directory to store graph diagrams
 │
-└── .logs/    [.gitignore]    # Local directory to store error/warning logs for debugging
+└── .logs/      [.gitignore]  # Local directory to store error/warning logs for debugging
 │
 │
 pyproject.toml                # Project config
+.env.sample                   # sample .env file
 
 ```
 
@@ -475,16 +476,7 @@ pyproject.toml                # Project config
 
 ### Adding env secrets to .env file
 
-Create `.env` file in the project root and add following:
-
-   ```
-   OPENAI_API_KEY=your-openai-api-key
-   GEMINI_API_KEY=your-gemini-api-key
-   LITELLM_API_KEY=your-litellm-api-key
-   COMPOSIO_API_KEY=your-composio-api-key
-   COMPOSIO_CLI_KEY=your-composio-cli-key
-   [OTHER_LLM_INTERFACE_PROVIDER_OF_YOUR_CHOICE]_API_KEY=your-api-key
-   ```
+Create `.env` file in the project root and add secret vars following `.env.sample` file.
 
 
 <hr />

{versionhq-1.2.1.5.dist-info → versionhq-1.2.1.6.dist-info}/RECORD

@@ -1,4 +1,4 @@
-versionhq/__init__.py,sha256=zh62wJK4H9QFpeR2SWXHuFDB8fvp-sN1ygezYC4pQGU,2817
+versionhq/__init__.py,sha256=Qi68iCRR29ZUfpZOVR_1Bcag4DdJi3xJsYJQOsZCe3U,2882
 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
@@ -44,14 +44,16 @@ 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=qkAJ1ToeOHQFR3hqC8nJyU6msftPgm8yEPTrFfz77OA,6906
+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=y4scd9c_RFF32OmJqBL3BBxVPykR8fu2DWk_tIqNgXk,28429
+versionhq/task/model.py,sha256=54IxQvDbC2hhCDcAvA-MZuoNyT0k1UsYm8Kq7M3cMaE,28503
 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/model.py,sha256=TsszoTJFeJ4TfSdLAjcGa9QSQyf9Uy3WmechTw0qL3k,22832
+versionhq/task_graph/colors.py,sha256=naJCx4Vho4iuJtbW8USUXb-M5uYvd5ds2p8qbjUfRus,669
+versionhq/task_graph/draft.py,sha256=nALpwFIDEEhij64ezMRKyNhmyyiXIhzA-6wpcU35xIs,4772
+versionhq/task_graph/model.py,sha256=ZXpuG6f1OZBrGV0Ai1kBuRDNSlwj17WH5GAuWvTWjFQ,23545
 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
@@ -59,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.5.dist-info/LICENSE,sha256=cRoGGdM73IiDs6nDWKqPlgSv7aR4n-qBXYnJlCMHCeE,1082
-versionhq-1.2.1.5.dist-info/METADATA,sha256=NdmB2VpDlH4dUaxzey8BSIjMlMzB1vj4tTrpYF00LdE,22395
-versionhq-1.2.1.5.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-versionhq-1.2.1.5.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
-versionhq-1.2.1.5.dist-info/RECORD,,
+versionhq-1.2.1.6.dist-info/LICENSE,sha256=cRoGGdM73IiDs6nDWKqPlgSv7aR4n-qBXYnJlCMHCeE,1082
+versionhq-1.2.1.6.dist-info/METADATA,sha256=i-9oGWPZtHYMDxHIgNofj54Lg2E2nryyD4jKFFm6T9Q,22204
+versionhq-1.2.1.6.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+versionhq-1.2.1.6.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
+versionhq-1.2.1.6.dist-info/RECORD,,