versionhq 1.1.13.1__py3-none-any.whl → 1.2.0.2__py3-none-any.whl

versionhq/__init__.py

@@ -17,7 +17,7 @@ from versionhq.knowledge.model import Knowledge, KnowledgeStorage
 from versionhq.knowledge.source import PDFKnowledgeSource, CSVKnowledgeSource, JSONKnowledgeSource, TextFileKnowledgeSource, ExcelKnowledgeSource, StringKnowledgeSource
 from versionhq.knowledge.source_docling import DoclingSource
 from versionhq.network.model import TaskStatus, TaskGraph, Node, Edge, DependencyType
-from versionhq.task.model import Task, TaskOutput, ConditionalTask, ResponseField
+from versionhq.task.model import Task, TaskOutput, ResponseField, TaskExecutionType
 from versionhq.task.evaluate import Evaluation, EvaluationItem
 from versionhq.team.model import Team, TeamOutput, Formation, Member, TaskHandlingProcess
 from versionhq.tool.model import Tool, ToolSet
@@ -30,7 +30,7 @@ from versionhq.memory.model import ShortTermMemory,LongTermMemory, UserMemory, M
 from versionhq.task.formation import form_agent_network
 
 
-__version__ = "1.1.13.1"
+__version__ = "1.2.0.2"
 __all__ = [
     "Agent",
 
@@ -64,8 +64,8 @@ __all__ = [
 
     "Task",
     "TaskOutput",
-    "ConditionalTask",
     "ResponseField",
+    "TaskExecutionType",
 
     "Evaluation",
     "EvaluationItem",

versionhq/agent/model.py

@@ -584,4 +584,4 @@ class Agent(BaseModel):
 
 
     def __repr__(self):
-        return f"Agent(role={self.role}, goal={self.goal}, backstory={self.backstory})"
+        return f"Agent(role={self.role}, goal={self.goal}"

versionhq/network/model.py

@@ -1,23 +1,22 @@
 import enum
 import uuid
 from abc import ABC
-from typing import List, Any, Optional, Callable, Dict, Type
+from typing import List, Any, Optional, Callable, Dict, Type, Tuple
 
-from pydantic import BaseModel, InstanceOf, Field, UUID4, PrivateAttr, field_validator
+from pydantic import BaseModel, InstanceOf, Field, UUID4, PrivateAttr, field_validator, model_validator
 from pydantic_core import PydanticCustomError
 
-from versionhq.task.model import Task
+from versionhq.task.model import Task, TaskOutput
 from versionhq.agent.model import Agent
 from versionhq._utils.logger import Logger
 
-
 try:
-   import networkx as ntx
+   import networkx as nx
 except ImportError:
     try:
         import os
         os.system("uv add networkx --optional networkx")
-        import networkx as ntx
+        import networkx as nx
     except:
         raise ImportError("networkx is not installed. Please install it with: uv add networkx --optional networkx")
 
@@ -43,18 +42,17 @@ class TaskStatus(enum.Enum):
     """
     NOT_STARTED = 1
     IN_PROGRESS = 2
-    BLOCKED = 3      # task is waiting for its dependant tasks to complete. resumption set as AUTO.
+    WAITING = 3     # waiting for its dependant tasks to complete. resumption set as AUTO.
     COMPLETED = 4
-    DELAYED = 5      # task has begun - but is taking longer than expected duration and behind schedule.
-    ON_HOLD = 6      # task is temporarily & intentionally paused due to external factors and/or decisions. resumption set as DECISION.
-
+    DELAYED = 5     # task in progress - but taking longer than expected duration
+    ON_HOLD = 6     # intentionally paused due to external factors and decisions. resumption set as DECISION.
+    ERROR = 7       # tried task execute but returned error. resupmtion follows edge weights and agent settings
 
 
 class DependencyType(enum.Enum):
     """
     Concise enumeration of the edge type.
     """
-
     FINISH_TO_START = "FS"  # Task B starts after Task A finishes
     START_TO_START = "SS"  # Task B starts when Task A starts
     FINISH_TO_FINISH = "FF"  # Task B finishes when Task A finishes
@@ -86,7 +84,7 @@ class Node(BaseModel):
     """
     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 to execute the task")
+    # trigger_event: TriggerEvent = Field(default=TriggerEvent.IMMEDIATE, description="store trigger event for starting the task execution")
     in_degree_nodes: List[Any] = Field(default=None, description="list of Node objects")
     out_degree_nodes: List[Any] = Field(default=None, description="list of Node objects")
     assigned_to: InstanceOf[Agent] = Field(default=None)
@@ -119,49 +117,110 @@ class Node(BaseModel):
         """Unique identifier for the node"""
         return f"{str(self.id)}"
 
+    def handle_task_execution(self, agent: Agent = None, context: str = None) -> TaskOutput | None:
+        """
+        Start task execution and update status accordingly.
+        """
+
+        self.status = TaskStatus.IN_PROGRESS
+
+        if not self.task:
+            Logger(verbose=True).log(level="error", message="Missing a task to execute. We'll return None.", color="red")
+            self.status = TaskStatus.ERROR
+            return None
+
+        res = self.task.execute(agent=agent, context=context)
+        self.status = TaskStatus.COMPLETED if res else TaskStatus.ERROR
+        return res
+
     def __str__(self):
         return self.identifier
 
 
+
 class Edge(BaseModel):
     """
-    A class to store an edge object that connects multiple nodes as dependencies.
+    A class to store an edge object that connects source and target nodes.
     """
+    source: Node = Field(default=None)
+    target: Node = Field(default=None)
+
     description: Optional[str] = Field(default=None)
+    weight: Optional[float | int] = Field(default=1, description="est. duration for the task execution or respective weight of the target node (1 low - 10 high priority)")
 
-    type: DependencyType = Field(default=DependencyType.FINISH_TO_START)
-    weight: Optional[float] = Field(default=None, description="duration or weight of the dependency: 1 light 10 heavy")
-    lag: Optional[float] = Field(default=None, description="lag time for the dependency to be executed")
-    constraint: Optional[str] = Field(default=None, description="constraint to consider executing the dependency")
-    priority: Optional[int] = Field(default=None, description="priority of the dependency if multiple depencencies are given")
+    dependency_type: DependencyType = Field(default=DependencyType.FINISH_TO_START)
+    required: bool = Field(default=True, description="whether to consider the source's status")
+    condition: Optional[Callable] = Field(default=None, description="conditional function to start executing the dependency")
+    condition_kwargs: Optional[Dict[str, Any]] = Field(default_factory=dict)
 
-    data_transfer: bool = Field(True, description="whether the data transfer is required")
-    data_format: Optional[str] = Field(default=None, description="Format of data transfer")
+    lag: Optional[float | int] = Field(default=None, description="lag time (sec) from the dependency met to the task execution")
+    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")
 
-    # execution logic
-    required: bool = Field(True, description="whether the execution of the dependency is required - False = conditional, optional task")
-    condition: Optional[Callable] = Field(default=None, description="conditional function to start executing the dependency")
 
+    def dependency_met(self) -> bool:
+        """
+        Defines if the dependency is ready to execute:
 
-    def is_dependency_met(self, predecessor_node: Node = None) -> bool:
+        required - condition - Dependency Met? - Dependent Task Can Start?
+        True	Not Given	Predecessor task finished	Yes
+        True	Given	Predecessor task finished and condition True	Yes
+        False	Not Given	Always (regardless of predecessor status)	Yes
+        False	Given	Condition True (predecessor status irrelevant)	Yes
         """
-        Define if the dependency is ready to execute:
 
-        required	condition	Dependency Met?	Dependent Task Can Start?
-        True	Not Given	Predecessor task finished	Yes (if other deps met)
-        True	Given	Predecessor task finished and condition True	Yes (if other deps met)
-        False	Not Given	Always (regardless of predecessor status)	Yes (if other deps met)
-        False	Given	Condition True (predecessor status irrelevant)	Yes (if other deps met)
+        if not self.required:
+            return self.condition(**self.condition_kwargs) if self.condition else True
+
+        match self.dependency_type:
+            case DependencyType.FINISH_TO_START:
+                """target starts after source finishes"""
+                if self.source.status == TaskStatus.COMPLETED:
+                    return self.condition(**self.conditon_kwargs) if self.condtion else True
+                else:
+                    return False
+
+            case DependencyType.START_TO_START:
+                """target starts when source starts"""
+                if self.source.status != TaskStatus.NOT_STARTED:
+                    return self.condition(**self.conditon_kwargs) if self.condtion else True
+                else:
+                    return False
+
+            case DependencyType.FINISH_TO_FINISH:
+                """target finish when source start"""
+                if self.source.status != TaskStatus.COMPLETED:
+                    return self.condition(**self.conditon_kwargs) if self.condtion else True
+                else:
+                    return False
+
+            case DependencyType.START_TO_FINISH:
+                """target finishes when source start"""
+                if self.source.status == TaskStatus.IN_PROGRESS:
+                    return self.condition(**self.conditon_kwargs) if self.condtion else True
+                else:
+                    return False
+
+
+    def activate(self) -> TaskOutput | None:
+        """
+        Activates the edge to initiate task execution of the target node.
         """
 
-        if self.required:
-            if predecessor_node.status == TaskStatus.COMPLETED:
-                return self.condition() if self.condtion else True
-            else:
-                return False
-        else:
-            return self.condition() if self.condition else True
+        if not self.dependency_met():
+            Logger(verbose=True).log(level="warning", message="Dependencies not met. We'll return None.", color="yellow")
+            return None
+
+        if not self.source or not self.target:
+            Logger(verbose=True).log(level="warning", message="Cannot find source or target nodes. We'll return None.", color="yellow")
+            return None
+
+        if self.lag:
+            import time
+            time.sleep(self.lag)
 
+        context = self.source.task.task_output.raw if self.data_transfer else None
+        res = self.target.handle_task_execution(context=context)
+        return res
 
 
 class Graph(ABC, BaseModel):
@@ -176,16 +235,20 @@ class Graph(ABC, BaseModel):
     edges: Dict[str, InstanceOf[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()
 
+    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
+
     def add_node(self, node: Node) -> None:
         self.graph.add_node(node.identifier, **node.model_dump())
         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.target = self._return_node_object(target)
         self.edges[(source, target)] = edge
 
     def add_weighted_edges_from(self, edges):
@@ -200,7 +263,7 @@ class Graph(ABC, BaseModel):
     def get_out_degree(self, node: Node) -> int:
         return self.graph.out_degree(node)
 
-    def find_path(self, source: str, target: str, weight: Any) -> Any:
+    def find_path(self, source: Optional[str] | None, target: str, weight: Optional[Any] | None) -> Any:
         try:
             return nx.shortest_path(self.graph, source=source, target=target, weight=weight)
         except nx.NetworkXNoPath:
@@ -209,7 +272,6 @@ class Graph(ABC, BaseModel):
     def find_all_paths(self,  source: str, target: str) -> List[Any]:
         return list(nx.all_simple_paths(self.graph, source=source, target=target))
 
-
     def find_critical_path(self) -> tuple[List[Any], int, Dict[str, int]]:
         """
         Finds the critical path in the graph.
@@ -245,7 +307,7 @@ class Graph(ABC, BaseModel):
             return False
 
 
-    def visualize(self, title: str = "Graph Visualization", pos: Any = None, **graph_config):
+    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,
@@ -270,12 +332,11 @@ class Graph(ABC, BaseModel):
         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 identifire and TaskOutput")
 
     def add_task(self, task: Node | Task) -> Node:
         """Convert `task` to a Node object and add it to G"""
@@ -352,7 +413,7 @@ class TaskGraph(Graph):
         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)  # Width proportional to weight (adjust scaling as needed)
+            edge_widths.append(v.weight * 0.5)
 
         nx.draw(
             self.graph, pos,
@@ -392,3 +453,48 @@ class TaskGraph(Graph):
 
         except Exception as e:
             self._logger.log(level="error", message=f"Failed to save the graph {str(self.id)}: {str(e)}", color="red")
+
+
+    def activate(self, target_node_identifier: Optional[str] = None) -> Tuple[TaskOutput | None, Dict[str, TaskOutput]]:
+        """
+        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)
+        """
+        if target_node_identifier:
+            if not [k for k in self.nodes.keys() if k == target_node_identifier]:
+                self._logger.log(level="error", message=f"The node {str(target_node_identifier)} is not in the graph.", color="red")
+                return None
+
+            # find a shortest path to each in-degree node of the node and see if dependency met.
+            node = self._return_node_object(target_node_identifier)
+            sources = node.in_degrees
+            edge_status = []
+            res = None
+
+            for item in sources:
+                edge = self.find_path(source=item, target=target_node_identifier)
+                edge_status.append(dict(edge=edge if edge else None, dep_met=edge.dependency_met() if edge else False))
+
+            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
+
+        else:
+            if not self.edges or self.nodes:
+                self._logger.log(level="error", message="Needs at least 2 nodes and 1 edge to activate the graph. We'll return None.", color="red")
+                return None
+
+            for edge in self.edges:
+                res = edge.activate()
+                if not res:
+                    break
+
+                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 last_task_output, self.outputs

versionhq/task/evaluate.py

@@ -72,7 +72,7 @@ class EvaluationItem(BaseModel):
 
 class Evaluation(BaseModel):
     items: List[EvaluationItem] = []
-    latency: int = Field(default=None, description="job execution latency in seconds")
+    latency: float = Field(default=None, description="job execution latency in seconds")
     tokens: int = Field(default=None, description="tokens consumed")
     eval_by: Any = Field(default=None, description="stores agent object that evaluates the outcome")
 

versionhq/task/formation.py

@@ -79,7 +79,7 @@ def form_agent_network(
         if agents:
             vhq_task.description += "Consider adding following agents in the formation: " + ", ".join([agent.role for agent in agents if isinstance(agent, Agent)])
 
-        res = vhq_task.execute_sync(agent=vhq_formation_planner, context=context)
+        res = vhq_task.execute(agent=vhq_formation_planner, context=context)
         _formation = Formation.SUPERVISING
 
         if res.pydantic:

versionhq/task/model.py

@@ -3,6 +3,7 @@ import threading
 import datetime
 import uuid
 import inspect
+import enum
 from concurrent.futures import Future
 from hashlib import md5
 from typing import Any, Dict, List, Set, Optional, Callable, Type
@@ -11,18 +12,25 @@ from typing_extensions import Annotated, Self
 from pydantic import UUID4, BaseModel, Field, PrivateAttr, field_validator, model_validator, InstanceOf, field_validator
 from pydantic_core import PydanticCustomError
 
-
+import versionhq as vhq
 from versionhq.task.log_handler import TaskOutputStorageHandler
 from versionhq.task.evaluate import Evaluation, EvaluationItem
 from versionhq.tool.model import Tool, ToolSet
 from versionhq._utils import process_config, Logger
 
 
+class TaskExecutionType(enum.Enum):
+    """
+    Enumeration to store task execution types of independent tasks without dependencies.
+    """
+    SYNC = 1
+    ASYNC = 2
+
+
 class ResponseField(BaseModel):
     """
-    A class to store the response format and schema that will cascade to the LLM.
-    The `config` field can store additional params:
-    https://community.openai.com/t/official-documentation-for-supported-schemas-for-response-format-parameter-in-calls-to-client-beta-chats-completions-parse/932422/3
+    A class to store a response format that will generate a JSON schema.
+    One layer of nested child is acceptable.
     """
 
     title: str = Field(default=None, description="title of the field")
@@ -31,7 +39,7 @@ class ResponseField(BaseModel):
     properties: Optional[List[BaseModel]] = Field(default=None, description="store dict items in ResponseField format")
     required: bool = Field(default=True)
     nullable: bool = Field(default=False)
-    config: Optional[Dict[str, Any]] = Field(default=None, description="additional rules")
+    config: Optional[Dict[str, Any]] = Field(default_factory=dict, description="additional rules")
 
 
     @model_validator(mode="after")
@@ -57,36 +65,44 @@ class ResponseField(BaseModel):
 
     def _format_props(self) -> Dict[str, Any]:
         """
-        Structure valid properties. We accept 2 nested objects.
+        Structure valid properties from the ResponseField object. 1 layer of nested child is accepted.
         """
         from versionhq.llm.llm_vars import SchemaType
 
         schema_type = SchemaType(type=self.data_type).convert()
         props: Dict[str, Any] = {}
 
-        if self.data_type is list and self.items is not dict:
-            props = {
-                "type": schema_type,
-                "items": { "type": SchemaType(type=self.items).convert() },
-            }
-
-        elif self.data_type is list and self.items is dict:
-            nested_p, nested_r = dict(), list()
+        if self.data_type is list:
+            if self.items is dict:
+                nested_p, nested_r = dict(), list()
+
+                if self.properties:
+                    for item in self.properties:
+                        nested_p.update(**item._format_props())
+                        nested_r.append(item.title)
+
+                props = {
+                    "type": schema_type,
+                    "items": {
+                        "type": SchemaType(type=self.items).convert(),
+                        "properties": nested_p,
+                        "required": nested_r,
+                        "additionalProperties": False
+                    }
+                }
 
-            if self.properties:
-                for item in self.properties:
-                    nested_p.update(**item._format_props())
-                    nested_r.append(item.title)
+            elif self.items is list:
+                props = {
+                    "type": schema_type,
+                    "items": { "type": SchemaType(type=self.items).convert(), "items": { "type": SchemaType(type=str).convert() }},
+                }
 
-            props = {
-                "type": schema_type,
-                "items": {
-                    "type": SchemaType(type=self.items).convert(),
-                    "properties": nested_p,
-                    "required": nested_r,
-                    "additionalProperties": False
+            else:
+                props = {
+                    "type": schema_type,
+                    "items": { "type": SchemaType(type=self.items).convert() },
                 }
-            }
+
 
         elif self.data_type is dict:
             p, r = dict(), list()
@@ -184,17 +200,16 @@ class TaskOutput(BaseModel):
         return json.dumps(self.json_dict) if self.json_dict else self.raw[0: 127]
 
 
-    def evaluate(self, task, latency: int | float = None, tokens: int = None) -> Evaluation:
+    def evaluate(self, task) -> Evaluation:
         """
         Evaluate the output based on the criteria, score each from 0 to 1 scale, and raise suggestions for future improvement.
         """
         from versionhq.task.TEMPLATES.Description import EVALUATE
 
-        if not self.evaluation:
-            self.evaluation = Evaluation()
+        self.evaluation = Evaluation() if not self.evaluation else self.evaluation
 
-        self.evaluation.latency = latency if latency is not None else task.latency
-        self.evaluation.tokens = tokens if tokens is not None else task.tokens
+        # self.evaluation.latency = latency if latency is not None else task.latency
+        # self.evaluation.tokens = tokens if tokens is not None else task.tokens
 
         eval_criteria = task.eval_criteria if task.eval_criteria else  ["Overall competitiveness", ]
 
@@ -203,7 +218,7 @@ class TaskOutput(BaseModel):
                 description=EVALUATE.format(task_description=task.description, task_output=self.raw, eval_criteria=str(item)),
                 pydantic_output=EvaluationItem
             )
-            res = task_eval.execute_sync(agent=self.evaluation.eval_by)
+            res = task_eval.execute(agent=self.evaluation.eval_by)
 
             if res.pydantic:
                 item = EvaluationItem(score=res.pydantic.score, suggestion=res.pydantic.suggestion, criteria=res.pydantic.criteria)
@@ -241,7 +256,7 @@ class TaskOutput(BaseModel):
 
 class Task(BaseModel):
     """
-    A class that stores independent task information.
+    A class that stores independent task information and handles task executions.
     """
 
     __hash__ = object.__hash__
@@ -255,8 +270,8 @@ class Task(BaseModel):
     description: str = Field(description="Description of the actual task")
 
     # output
-    pydantic_output: Optional[Any] = Field(default=None, description="store a custom Pydantic class as response format")
-    response_fields: List[ResponseField] = Field(default_factory=list, description="store the list of ResponseFields to create the response format")
+    pydantic_output: Optional[Type[BaseModel]] = Field(default=None, description="store Pydantic class as structured response format")
+    response_fields: Optional[List[ResponseField]] = Field(default_factory=list, description="store list of ResponseField as structured response format")
     output: Optional[TaskOutput] = Field(default=None, description="store the final task output in TaskOutput class")
 
     # task setup
@@ -269,8 +284,8 @@ class Task(BaseModel):
     tool_res_as_final: bool = Field(default=False, description="when set True, tools res will be stored in the `TaskOutput`")
 
     # execution rules
+    execution_type: TaskExecutionType = Field(default=TaskExecutionType.SYNC)
     allow_delegation: bool = Field(default=False, description="ask other agents for help and run the task instead")
-    async_execution: bool = Field(default=False,description="whether the task should be executed asynchronously or not")
     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")
 
@@ -408,11 +423,7 @@ Ref. Output image: {output_formats_to_follow}
                 properties, required_fields = {}, []
                 for i, item in enumerate(self.response_fields):
                     if item:
-                        if item.data_type is dict:
-                            properties.update(item._format_props())
-                        else:
-                            properties.update(item._format_props())
-
+                        properties.update(item._format_props())
                         required_fields.append(item.title)
 
                 response_schema = {
@@ -421,7 +432,6 @@ Ref. Output image: {output_formats_to_follow}
                     "required": required_fields,
                     "additionalProperties": False,
                 }
-
                 response_format = {
                     "type": "json_schema",
                     "json_schema": { "name": "outcome", "schema": response_schema }
@@ -429,7 +439,7 @@ Ref. Output image: {output_formats_to_follow}
 
 
             elif self.pydantic_output:
-                response_format = StructuredOutput(response_format=self.pydantic_output)._format()
+                response_format = StructuredOutput(response_format=self.pydantic_output, provider=model_provider)._format()
 
             return response_format
 
@@ -481,7 +491,6 @@ Ref. Output image: {output_formats_to_follow}
 
             for k, v in json_dict.items():
                 setattr(output_pydantic, k, v)
-
         except:
             pass
 
@@ -536,9 +545,35 @@ Ref. Output image: {output_formats_to_follow}
             self._logger.log(level="error", message=f"Failed to add to the memory: {str(e)}", color="red")
             pass
 
+    def _build_agent_from_task(self, task_description: str = None) -> InstanceOf["vhq.Agent"]:
+        task_description = task_description if task_description else self.description
+        if not task_description:
+            self._logger.log(level="error", message="Task is missing the description.", color="red")
+            pass
+
+        agent = vhq.Agent(goal=task_description, role=task_description, maxit=1) #! REFINEME
+        return agent
+
 
     # task execution
-    def execute_sync(self, agent, context: Optional[str | List[Any]] = None) -> TaskOutput:
+    def execute(self, type: TaskExecutionType = None, agent: Optional[Any] = None, context: Optional[str] = None) -> TaskOutput | Future[TaskOutput]:
+        """
+        A main method to handle task execution. Build an agent when the agent is not given.
+        """
+        type = type if type else  self.execution_type if self.execution_type else TaskExecutionType.SYNC
+
+        if not agent:
+            agent = self._build_agent_from_task(task_description=self.description)
+
+        match type:
+            case TaskExecutionType.SYNC:
+                return self._execute_sync(agent=agent, context=context)
+
+            case TaskExecutionType.ASYNC:
+                return self._execute_async(agent=agent, context=context)
+
+
+    def _execute_sync(self, agent, context: Optional[str | List[Any]] = None) -> TaskOutput:
         """
         Execute the task synchronously.
         When the task has context, make sure we have executed all the tasks in the context first.
@@ -553,7 +588,7 @@ Ref. Output image: {output_formats_to_follow}
         return self._execute_core(agent, context)
 
 
-    def execute_async(self, agent, context: Optional[str] = None) -> Future[TaskOutput]:
+    def _execute_async(self, agent, context: Optional[str] = None) -> Future[TaskOutput]:
         """
         Execute the task asynchronously.
         """
@@ -565,7 +600,7 @@ Ref. Output image: {output_formats_to_follow}
 
     def _execute_task_async(self, agent, context: Optional[str], future: Future[TaskOutput]) -> None:
         """
-        Execute the task asynchronously with context handling.
+        Executes the task asynchronously with context handling.
         """
 
         result = self._execute_core(agent, context)
@@ -574,8 +609,8 @@ Ref. Output image: {output_formats_to_follow}
 
     def _execute_core(self, agent, context: Optional[str]) -> TaskOutput:
         """
-        Execute the given task with the given agent.
-        Handle 1. agent delegation, 2. tools, 3. context to consider, and 4. callbacks
+        A core method for task execution.
+        Handles 1. agent delegation, 2. tools, 3. context to add to the prompt, and 4. callbacks
         """
 
         from versionhq.agent.model import Agent
@@ -634,13 +669,13 @@ Ref. Output image: {output_formats_to_follow}
                 json_dict=json_dict_output
             )
 
-
         self.latency = (ended_at - started_at).total_seconds()
+        task_output.evaluation = Evaluation(latency=self.latency, tokens=self.tokens)
         self.output = task_output
         self.processed_agents.add(agent.role)
 
         if self.should_evaluate:
-            task_output.evaluate(task=self, latency=self.latency, tokens=self.tokens)
+            task_output.evaluate(task=self)
 
         self._create_short_and_long_term_memories(agent=agent, task_output=task_output)
 
@@ -648,7 +683,7 @@ Ref. Output image: {output_formats_to_follow}
             kwargs = { **self.callback_kwargs, **task_output.json_dict }
             sig = inspect.signature(self.callback)
             valid_keys = [param.name for param in sig.parameters.values() if param.kind == param.POSITIONAL_OR_KEYWORD]
-            valid_kwargs = { k: kwargs[k] for k in valid_keys }
+            valid_kwargs = { k: kwargs[k] if  k in kwargs else None for k in valid_keys }
             callback_res = self.callback(**valid_kwargs)
             task_output.callback_output = callback_res
 
@@ -687,50 +722,49 @@ Task ID: {str(self.id)}
 
 
 
-class ConditionalTask(Task):
-    """
-    A task that can be conditionally executed based on the output of another task.
-    When the `condition` return True, execute the task, else skipped with `skipped task output`.
-    """
+# class ConditionalTask(Task):
+#     """
+#     A task that can be conditionally executed based on the output of another task.
+#     When the `condition` return True, execute the task, else skipped with `skipped task output`.
+#     """
 
-    condition: Callable[[TaskOutput], bool] = Field(
-        default=None,
-        description="max. number of retries for an agent to execute a task when an error occurs",
-    )
+#     condition: Callable[[TaskOutput], bool] = Field(
+#         default=None,
+#         description="max. number of retries for an agent to execute a task when an error occurs",
+#     )
 
 
-    def __init__(self, condition: Callable[[Any], bool], **kwargs):
-        super().__init__(**kwargs)
-        self.condition = condition
-        self._logger = Logger(verbose=True)
+#     def __init__(self, condition: Callable[[Any], bool], **kwargs):
+#         super().__init__(**kwargs)
+#         self.condition = condition
 
 
-    def should_execute(self, context: TaskOutput) -> bool:
-        """
-        Decide whether the conditional task should be executed based on the provided context.
-        Return `True` if it should be executed.
-        """
-        return self.condition(context)
+#     def should_execute(self, context: TaskOutput) -> bool:
+#         """
+#         Decide whether the conditional task should be executed based on the provided context.
+#         Return `True` if it should be executed.
+#         """
+#         return self.condition(context)
 
 
-    def get_skipped_task_output(self):
-        return TaskOutput(task_id=self.id, raw="", pydantic=None, json_dict={})
+#     def get_skipped_task_output(self):
+#         return TaskOutput(task_id=self.id, raw="", pydantic=None, json_dict={})
 
 
-    def _handle_conditional_task(self, task_outputs: List[TaskOutput], task_index: int, was_replayed: bool) -> Optional[TaskOutput]:
-        """
-        When the conditional task should be skipped, return `skipped_task_output` as task_output else return None
-        """
+#     def _handle_conditional_task(self, task_outputs: List[TaskOutput], task_index: int, was_replayed: bool) -> Optional[TaskOutput]:
+#         """
+#         When the conditional task should be skipped, return `skipped_task_output` as task_output else return None
+#         """
 
-        previous_output = task_outputs[task_index - 1] if task_outputs and len(task_outputs) > 1  else None
+#         previous_output = task_outputs[task_index - 1] if task_outputs and len(task_outputs) > 1  else None
 
-        if previous_output and not self.should_execute(previous_output):
-            self._logger.log(level="warning", message=f"Skipping conditional task: {self.description}", color="yellow")
-            skipped_task_output = self.get_skipped_task_output()
-            self.output = skipped_task_output
+#         if previous_output and not self.should_execute(previous_output):
+#             self._logger.log(level="warning", message=f"Skipping conditional task: {self.description}", color="yellow")
+#             skipped_task_output = self.get_skipped_task_output()
+#             self.output = skipped_task_output
 
-            if not was_replayed:
-                self._store_execution_log(self, task_index=task_index, was_replayed=was_replayed, inputs={})
-            return skipped_task_output
+#             if not was_replayed:
+#                 self._store_execution_log(self, task_index=task_index, was_replayed=was_replayed, inputs={})
+#             return skipped_task_output
 
-        return None
+#         return None

versionhq/task/structured_response.py

@@ -3,11 +3,11 @@ from typing import Dict, Type, List, Any
 from pydantic import BaseModel, Field, InstanceOf
 
 from versionhq.llm.llm_vars import SchemaType
-from versionhq.llm.model import LLM
+from versionhq.llm.model import LLM, DEFAULT_MODEL_PROVIDER_NAME
 
 
 """
-Structure a response schema (json schema) from the given Pydantic model.
+Generate a JSON schema from the given Pydantic model.
 """
 
 
@@ -15,7 +15,7 @@ class StructuredObject:
     """
     A class to store the structured dictionary.
     """
-    provider: str = "openai"
+    provider: str = None
     field: Type[Field]
 
     title: str
@@ -24,20 +24,21 @@ class StructuredObject:
     required: List[str] = list()
     additionalProperties: bool = False
 
-    def __init__(self, name, field: Type[Field], provider: str | InstanceOf[LLM] = "openai"):
+    def __init__(self, name, field: Type[Field], provider: str | InstanceOf[LLM] = None):
         self.title = name
         self.field = field
         self.dtype = "object"
         self.additionalProperties = False
-        self.provider = provider if isinstance(provider, str) else provider.provider
+        self.provider = provider if isinstance(provider, str) else provider.provider if isinstance(provider, LLM) else DEFAULT_MODEL_PROVIDER_NAME
 
     def _format(self):
         if not self.field:
             pass
         else:
             description = self.field.description if hasattr(self.field, "description") and self.field.description is not None else ""
-            self.properties.update({"item": { "type": SchemaType(self.field.annotation.__args__).convert() }})
-            self.required.append("item")
+            field_name = self.field.__name__ if hasattr(self.field, "__name__") and self.field.__name__ else self.title
+            self.properties.update({ field_name : { "type": SchemaType(self.field.annotation.__args__).convert() }})
+            self.required.append(field_name)
 
             return {
                 self.title: {
@@ -55,13 +56,13 @@ class StructuredList:
     """
     A class to store a structured list with 1 nested object.
     """
-    provider: str = "openai"
+    provider: str = DEFAULT_MODEL_PROVIDER_NAME
     field: Type[Field]
     title: str = ""
     dtype: str = "array"
     items: Dict[str, Dict[str, str]] = dict()
 
-    def __init__(self, name, field: Type[Field], provider: str | LLM = "openai"):
+    def __init__(self, name, field: Type[Field], provider: str | LLM = DEFAULT_MODEL_PROVIDER_NAME):
         self.provider = provider if isinstance(provider, str) else provider.provider
         self.field = field
         self.title = name
@@ -77,15 +78,15 @@ class StructuredList:
             description = "" if field.description is None else field.description
             props = {}
 
-            for item in field.annotation.__args__:
+            for i, item in enumerate(field.annotation.__args__):
                 nested_object_type = item.__origin__ if hasattr(item, "__origin__") else item
 
                 if nested_object_type == dict:
                     props.update({
                         # "nest":  {
                             "type": "object",
-                            "properties": { "item": { "type": "string"} }, #! REFINEME - field title <>`item`
-                            "required": ["item",],
+                            "properties": { f"{str(i)}": { "type": "string"} },
+                            "required": [f"{str(i)}",],
                             "additionalProperties": False
                         # }
                         })
@@ -94,13 +95,14 @@ class StructuredList:
                     props.update({
                         # "nest":  {
                             "type": "array",
-                            "items": { "type": "string" } , #! REFINEME - field title <>`item`
+                            "items": { "type": "string" },
                         # }
                         })
                 else:
                     props.update({ "type": SchemaType(nested_object_type).convert() })
 
             self.items = { **props }
+
             return {
                  self.title: {
                     "type": self.dtype,
@@ -112,7 +114,7 @@ class StructuredList:
 
 class StructuredOutput(BaseModel):
     response_format: Any = None # pydantic base model
-    provider: str = "openai"
+    provider: str = None
     applicable_models: List[InstanceOf[LLM] | str] = list()
     name: str = ""
     schema: Dict[str, Any] = dict(type="object", additionalProperties=False, properties=dict(), required=list())

versionhq/team/model.py

@@ -10,7 +10,7 @@ from pydantic._internal._generate_schema import GenerateSchema
 from pydantic_core import PydanticCustomError, core_schema
 
 from versionhq.agent.model import Agent
-from versionhq.task.model import Task, TaskOutput, ConditionalTask
+from versionhq.task.model import Task, TaskOutput, TaskExecutionType
 from versionhq.task.formatter import create_raw_outputs
 from versionhq.team.team_planner import TeamPlanner
 from versionhq._utils.logger import Logger
@@ -215,7 +215,7 @@ class Team(BaseModel):
         for task in reversed(self.tasks):
             if not task:
                 break
-            elif task.async_execution:
+            elif task.execution_type == TaskExecutionType.ASYNC:
                 async_task_count += 1
             else:
                 break
@@ -341,7 +341,7 @@ class Team(BaseModel):
         for task_index, task in enumerate(tasks):
             if start_index is not None and task_index < start_index:
                 if task.output:
-                    if task.async_execution:
+                    if task.execution_type == TaskExecutionType.ASYNC:
                         task_outputs.append(task.output)
                     else:
                         task_outputs = [task.output]
@@ -352,20 +352,21 @@ class Team(BaseModel):
             if responsible_agent is None:
                 self._assign_tasks()
 
-            if isinstance(task, ConditionalTask):
-                skipped_task_output = task._handle_conditional_task(task_outputs, futures, task_index, was_replayed)
-                if skipped_task_output:
-                    continue
+            ## commented out - this will be handled by node objects
+            # if isinstance(task, ConditionalTask):
+            #     skipped_task_output = task._handle_conditional_task(task_outputs, futures, task_index, was_replayed)
+            #     if skipped_task_output:
+            #         continue
 
             # self._log_task_start(task, responsible_agent)
 
-            if task.async_execution:
+            if task.execution_type == TaskExecutionType.ASYNC:
                 context = create_raw_outputs(tasks=[task, ], task_outputs=([last_sync_output,] if last_sync_output else []))
-                future = task.execute_async(agent=responsible_agent, context=context)
+                future = task._execute_async(agent=responsible_agent, context=context)
                 futures.append((task, future, task_index))
             else:
                 context = create_raw_outputs(tasks=[task,], task_outputs=([last_sync_output,] if last_sync_output else [] ))
-                task_output = task.execute_sync(agent=responsible_agent, context=context)
+                task_output = task.execute(agent=responsible_agent, context=context)
                 if self.managers and responsible_agent in [manager.agent for manager in self.managers]:
                     lead_task_output = task_output
 

versionhq/team/team_planner.py

@@ -3,8 +3,6 @@ from typing import Any, List, Optional, Dict
 from pydantic import BaseModel, Field
 
 
-
-
 class TeamPlanner:
     """
     A class to handle agent formations based on the given task description.
@@ -50,7 +48,7 @@ class TeamPlanner:
                     ResponseField(title="role", data_type=str, required=True),
                 ],
             )
-            res = task.execute_sync(agent=agent_creator)
+            res = task.execute(agent=agent_creator)
             agent = Agent(
                 role=res.json_dict["role"] if "role" in res.json_dict else res.raw,
                 goal=res.json_dict["goal"] if "goal" in res.json_dict else task.description
@@ -90,5 +88,5 @@ class TeamPlanner:
             """,
             pydantic_output=TeamPlanIdea
         )
-        output = task.execute_sync(agent=team_planner, context=context, tools=tools)
+        output = task.execute(agent=team_planner, context=context, tools=tools)
         return output

{versionhq-1.1.13.1.dist-info → versionhq-1.2.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: versionhq
-Version: 1.1.13.1
+Version: 1.2.0.2
 Summary: An agentic orchestration framework for building agent networks that handle task automation.
 Author-email: Kuriko Iwai <kuriko@versi0n.io>
 License: MIT License
@@ -86,8 +86,8 @@ Requires-Dist: matplotlib>=3.10.0; extra == "matplotlib"
 [![DL](https://img.shields.io/badge/Download-15K+-red)](https://clickpy.clickhouse.com/dashboard/versionhq)
 ![MIT license](https://img.shields.io/badge/License-MIT-green)
 [![Publisher](https://github.com/versionHQ/multi-agent-system/actions/workflows/publish.yml/badge.svg)](https://github.com/versionHQ/multi-agent-system/actions/workflows/publish.yml)
-![PyPI](https://img.shields.io/badge/PyPI-v1.1.12+-blue)
-![python ver](https://img.shields.io/badge/Python-3.11+-purple)
+![PyPI](https://img.shields.io/badge/PyPI-v1.2.0+-blue)
+![python ver](https://img.shields.io/badge/Python-3.11/3.12-purple)
 ![pyenv ver](https://img.shields.io/badge/pyenv-2.5.0-orange)
 
 
@@ -266,9 +266,6 @@ By default, agents prioritize JSON over plane text outputs.
    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")
-
    task = vhq.Task(
       description="Amazing task",
       pydantic_output=CustomOutput,
@@ -276,7 +273,7 @@ By default, agents prioritize JSON over plane text outputs.
       callback_kwargs=dict(message="Hi! Here is the result: ")
    )
 
-   res = task.execute_sync(agent=agent, context="amazing context to consider.")
+   res = task.execute(context="amazing context to consider.")
    print(res)
    ```
 
@@ -377,6 +374,7 @@ Tasks can be delegated to a team manager, peers in the team, or completely new a
 └── workflows/                # Github actions
 │
 docs/                         # Documentation built by MkDocs
+mkdocs.yml                    # MkDocs config
 │
 src/
 └── versionhq/                # Orchestration framework package
@@ -392,6 +390,8 @@ src/
 │     └── ...
 │
 └── uploads/  [.gitignore]    # Local directory to store uploaded files such as graphviz diagrams generatd by `Network` class
+|
+pyproject.toml                # Project config
 
 ```
 

{versionhq-1.1.13.1.dist-info → versionhq-1.2.0.2.dist-info}/RECORD

@@ -1,4 +1,4 @@
-versionhq/__init__.py,sha256=JJMdTbmmTzzublAjg3tFmOm13CKLwVsNz3cdsDP0bJQ,2780
+versionhq/__init__.py,sha256=RwVa60s3Puko2L4VU8tS7jAFhPy5zqbYqyJUdDhyjHA,2783
 versionhq/_utils/__init__.py,sha256=dzoZr4cBlh-2QZuPzTdehPUCe9lP1dmRtauD7qTjUaA,158
 versionhq/_utils/i18n.py,sha256=TwA_PnYfDLA6VqlUDPuybdV9lgi3Frh_ASsb_X8jJo8,1483
 versionhq/_utils/logger.py,sha256=j9SlQPIefdVUlwpGfJY83E2BUt1ejWgZ2M2I8aMyQ3c,1579
@@ -7,7 +7,7 @@ versionhq/_utils/usage_metrics.py,sha256=NXF18dn5NNvGK7EsQ4AAghpR8ppYOjMx6ABenLL
 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=vSobrH1gXDWlaNsiges3sqETeUrEssRzQvCZCY2hQZA,2374
-versionhq/agent/model.py,sha256=NLHQPYqYFg9GX3NoDP1Rs3vHFlYv6Fl6JZ4QlNOYMn0,25429
+versionhq/agent/model.py,sha256=kSYCAiRxF62ztj-S-_KfN0mhPKikjbFZ0fy2Yj5J7Jo,25400
 versionhq/agent/parser.py,sha256=riG0dkdQCxH7uJ0AbdVdg7WvL0BXhUgJht0VtQvxJBc,4082
 versionhq/agent/rpm_controller.py,sha256=grezIxyBci_lDlwAlgWFRyR5KOocXeOhYkgN02dNFNE,2360
 versionhq/agent/TEMPLATES/Backstory.py,sha256=IAhGnnt6VUMe3wO6IzeyZPDNu7XE7Uiu3VEXUreOcKs,532
@@ -34,7 +34,7 @@ versionhq/memory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,
 versionhq/memory/contextual_memory.py,sha256=tCsOOAUnfrOL7YiakqGoi3uShzzS870TmGnlGd3z_A4,3556
 versionhq/memory/model.py,sha256=4wow2O3UuMZ0AbC2NyxddGZac3-_GjNZbK9wsA015NA,8145
 versionhq/network/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-versionhq/network/model.py,sha256=npSV5RUYdmkM9cMGkNLiKD4vYb3yNVyh6qCdNKkVIN8,15223
+versionhq/network/model.py,sha256=nqRlekld7Hy0cQZCOXbOGpanTFJwWfHyJt1OodhHJI0,20316
 versionhq/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/storage/base.py,sha256=p-Jas0fXQan_qotnRD6seQxrT2lj-uw9-SmHQhdppcs,355
 versionhq/storage/ltm_sqlite_storage.py,sha256=wdUiuwHfJocdk0UGqyrdU4S5Nae1rgsoRNu3LWmGFcI,3951
@@ -43,16 +43,16 @@ versionhq/storage/rag_storage.py,sha256=ScWC0vH327vnGw8UGscAOoIfqrq3mhvXT3vEKzHZ
 versionhq/storage/task_output_storage.py,sha256=E1t_Fkt78dPYIOl3MP7LfQ8oGtjlzxBuSNq_8ZXKho8,4573
 versionhq/storage/utils.py,sha256=ByYXPoEIGJYLUqz-DWjbCAnneNrH1otiYbp12SCILpM,747
 versionhq/task/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-versionhq/task/evaluate.py,sha256=fBLL6sm763e3Ev6uU0tMqFRUVwAcBj6dLM5N062qHuc,3952
-versionhq/task/formation.py,sha256=QXFZfY604cpS79X7HEBmwFKn91H8jS3Ak6EhJGgaRIg,6355
+versionhq/task/evaluate.py,sha256=WdUgjbZL62XrxyWe5MTz29scfzwmuAHGxJ7GvAB8Fmk,3954
+versionhq/task/formation.py,sha256=iHhW2webMirYC78G8kHpaMTYjCdq7c3yFD2u2Egd8Eo,6350
 versionhq/task/formatter.py,sha256=N8Kmk9vtrMtBdgJ8J7RmlKNMdZWSmV8O1bDexmCWgU0,643
 versionhq/task/log_handler.py,sha256=LT7YnO7gcPR9IZS7eRvMjnHh8crMBFtqduxd8dxIbkk,1680
-versionhq/task/model.py,sha256=qbH_fMnkDqZUp-Sgd7LB7LMsXSaytMFMVffS5q3En1c,29160
-versionhq/task/structured_response.py,sha256=uVqgeUxNOACPe2hdc0RELSbtKd1vrwonfjXMOGTT0TI,4818
+versionhq/task/model.py,sha256=zAnZ-_5YKZRs43gpM2AL9IVtttq5GqGfqfCMj_Oyz9g,30624
+versionhq/task/structured_response.py,sha256=4q-hQPu7oMMHHXEzh9YW4SJ7N5eCZ7OfZ65juyl_jCI,5000
 versionhq/task/TEMPLATES/Description.py,sha256=V-4kh8xpQTKOcDMi2xnuP-fcNk6kuoz1_5tYBlDLQWQ,420
 versionhq/team/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-versionhq/team/model.py,sha256=qPsV3O3O2TIOT-3h142KVVFdO587LhoOeVkK2niZHEc,19062
-versionhq/team/team_planner.py,sha256=x1eLkdfQwW6w3Kyi_wVaVlA41TaNJDIYWhtEqp_OcaI,3675
+versionhq/team/model.py,sha256=kxrjF3RFGO9l3IsJIffI1nqgl_Vh5RLuhqrwIqbEoBY,19214
+versionhq/team/team_planner.py,sha256=Zc3zvhPR7T0O8RQoq9CKOrvrll4klemY1rONLFeJ96M,3663
 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
@@ -60,8 +60,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.1.13.1.dist-info/LICENSE,sha256=cRoGGdM73IiDs6nDWKqPlgSv7aR4n-qBXYnJlCMHCeE,1082
-versionhq-1.1.13.1.dist-info/METADATA,sha256=QAjiAx25V2-0nc9PGPNII3-31IHw8hHAghUfdQxZogA,21448
-versionhq-1.1.13.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-versionhq-1.1.13.1.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
-versionhq-1.1.13.1.dist-info/RECORD,,
+versionhq-1.2.0.2.dist-info/LICENSE,sha256=cRoGGdM73IiDs6nDWKqPlgSv7aR4n-qBXYnJlCMHCeE,1082
+versionhq-1.2.0.2.dist-info/METADATA,sha256=YT-m2KqdExbv9rb2uLSVoRjkMiB06pKExUqkduXFoM0,21462
+versionhq-1.2.0.2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+versionhq-1.2.0.2.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
+versionhq-1.2.0.2.dist-info/RECORD,,