versionhq 1.2.2.1__tar.gz → 1.2.2.3__tar.gz

{versionhq-1.2.2.1 → versionhq-1.2.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: versionhq
-Version: 1.2.2.1
+Version: 1.2.2.3
 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.2.1 → versionhq-1.2.2.3}/pyproject.toml

@@ -15,7 +15,7 @@ exclude = ["test*", "__pycache__", "*.egg-info"]
 
 [project]
 name = "versionhq"
-version = "1.2.2.1"
+version = "1.2.2.3"
 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.2.1 → versionhq-1.2.2.3}/src/versionhq/__init__.py

@@ -17,7 +17,7 @@ from versionhq.clients.workflow.model import MessagingWorkflow, MessagingCompone
 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.task_graph.model import TaskStatus, TaskGraph, Node, Edge, DependencyType
+from versionhq.task_graph.model import TaskStatus, TaskGraph, Node, Edge, DependencyType, Condition, ConditionType
 from versionhq.task.model import Task, TaskOutput, ResponseField, TaskExecutionType
 from versionhq.task.evaluation import Evaluation, EvaluationItem
 from versionhq.tool.model import Tool, ToolSet
@@ -31,7 +31,7 @@ from versionhq.agent_network.formation import form_agent_network
 from versionhq.task_graph.draft import workflow
 
 
-__version__ = "1.2.2.1"
+__version__ = "1.2.2.3"
 __all__ = [
     "Agent",
 
@@ -67,6 +67,8 @@ __all__ = [
     "Node",
     "Edge",
     "DependencyType",
+    "Condition",
+    "ConditionType",
 
     "Task",
     "TaskOutput",

{versionhq-1.2.2.1 → versionhq-1.2.2.3}/src/versionhq/agent_network/model.py

@@ -13,7 +13,7 @@ from pydantic_core import PydanticCustomError, core_schema
 
 from versionhq.agent.model import Agent
 from versionhq.task.model import Task, TaskOutput, TaskExecutionType, ResponseField
-from versionhq.task_graph.model import TaskGraph, Node, Edge, TaskStatus, DependencyType
+from versionhq.task_graph.model import TaskGraph, Node, Edge, TaskStatus, DependencyType, Condition
 from versionhq._utils.logger import Logger
 # from versionhq.recording.usage_metrics import UsageMetrics
 
@@ -81,7 +81,7 @@ class AgentNetwork(BaseModel):
     # task execution rules
     prompt_file: str = Field(default="", description="absolute file path to the prompt file that stores jsonified prompts")
     process: TaskHandlingProcess = Field(default=TaskHandlingProcess.SEQUENTIAL)
-    consent_trigger: Optional[Callable] = Field(default=None, description="returns bool")
+    consent_trigger: Optional[Callable | Condition] = Field(default=None, description="returns bool")
 
     # callbacks
     pre_launch_callbacks: List[Callable[..., Any]]= Field(default_factory=list, description="list of callback funcs called before the network launch")
@@ -111,6 +111,9 @@ class AgentNetwork(BaseModel):
             Logger().log(level="error", message="Need to define the consent trigger function that returns bool", color="red")
             raise PydanticCustomError("invalid_process", "Need to define the consent trigger function that returns bool", {})
 
+
+        if self.consent_trigger and isinstance(self.consent_trigger, Callable):
+            self.consent_trigger = Condition(methods={"0": self.consent_trigger})
         return self
 
 
@@ -263,6 +266,8 @@ class AgentNetwork(BaseModel):
             task = self.tasks[0]
             responsible_agent = self._get_responsible_agent(task=task)
             res = task.execute(agent=responsible_agent)
+            node = Node(task=task)
+            task_graph = TaskGraph(nodes={ node.identifier: node, }, concl=res if res else None)
             return res, task_graph
 
         nodes = [
@@ -275,6 +280,7 @@ class AgentNetwork(BaseModel):
         task_graph = TaskGraph(nodes={node.identifier: node for node in nodes})
 
         for i in range(0, len(nodes) - 1):
+            condition = self.consent_trigger if isinstance(self.consent_trigger, Condition) else Condition(methods={"0": self.consent_trigger }) if self.consent_trigger else None
             task_graph.add_edge(
                 source=nodes[i].identifier,
                 target=nodes[i+1].identifier,
@@ -282,7 +288,7 @@ class AgentNetwork(BaseModel):
                     weight=3 if nodes[i].task in self.manager_tasks else 1,
                     dependency_type=DependencyType.FINISH_TO_START if self.process == TaskHandlingProcess.HIERARCHY else DependencyType.START_TO_START,
                     required=bool(self.process == TaskHandlingProcess.CONSENSUAL),
-                    condition=self.consent_trigger,
+                    condition=condition,
                     data_transfer=bool(self.process == TaskHandlingProcess.HIERARCHY),
                 )
             )

{versionhq-1.2.2.1 → versionhq-1.2.2.3}/src/versionhq/knowledge/source_docling.py

@@ -9,10 +9,10 @@ try:
     from docling_core.transforms.chunker.hierarchical_chunker import HierarchicalChunker
     from docling_core.types.doc.document import DoclingDocument
     DOCLING_AVAILABLE = True
-except ImportError:
-    import envoy
-    envoy.run("uv add docling --optional docling")
-    DOCLING_AVAILABLE = True
+# except ImportError:
+    # import envoy
+    # envoy.run("uv add docling --optional docling")
+    # DOCLING_AVAILABLE = True
 except:
     DOCLING_AVAILABLE = False
 

{versionhq-1.2.2.1 → versionhq-1.2.2.3}/src/versionhq/memory/contextual_memory.py

@@ -23,25 +23,25 @@ class ContextualMemory:
         self.um = um
 
 
-    def build_context_for_task(self, query: str = None) -> str:
-        """
-        Automatically builds a minimal, highly relevant set of contextual information for a given task.
-        """
+    def _sanitize_query(self, query: str = None) -> str:
         if not query:
             return ""
 
-        context = []
-        context.append(self._fetch_stm_context(query))
-        if self.memory_provider == "mem0":
-            context.append(self._fetch_user_context(query))
-        return "\n".join(filter(None, context))
+        return query.replace("{", "").replace("}", "")
 
 
-    def _fetch_stm_context(self, query) -> str:
+    def _fetch_stm_context(self, query: str = None) -> str:
         """
-        Fetches recent relevant insights from STM related to the task's description and expected_output, formatted as bullet points.
+        Fetches recent relevant insights from STM
         """
+        if not query:
+            return ""
+
+
         stm_results = self.stm.search(query)
+        if not stm_results:
+            return ""
+
         formatted_results = "\n".join(
             [
                 f"- {result['memory'] if self.memory_provider == 'mem0' else result['context']}"
@@ -51,13 +51,16 @@ class ContextualMemory:
         return f"Recent Insights:\n{formatted_results}" if stm_results else ""
 
 
-    def _fetch_ltm_context(self, task) -> Optional[str]:
+    def _fetch_ltm_context(self, query: str = None) -> Optional[str]:
         """
         Fetches historical data or insights from LTM that are relevant to the task's description and expected_output, formatted as bullet points.
         """
-        ltm_results = self.ltm.search(task, latest_n=2)
+        if not query:
+            return ""
+
+        ltm_results = self.ltm.search(query, latest_n=2)
         if not ltm_results:
-            return None
+            return ""
 
         formatted_results = [suggestion for result in ltm_results for suggestion in result["metadata"]["suggestions"]]
         formatted_results = list(dict.fromkeys(formatted_results))
@@ -65,10 +68,12 @@ class ContextualMemory:
         return f"Historical Data:\n{formatted_results}" if ltm_results else ""
 
 
-    def _fetch_user_context(self, query: str) -> str:
+    def _fetch_user_context(self, query: str = None) -> str:
         """
         Fetches and formats relevant user information from User Memory.
         """
+        if not query:
+            return ""
 
         user_memories = self.um.search(query)
         if not user_memories:
@@ -78,6 +83,23 @@ class ContextualMemory:
         return f"User memories/preferences:\n{formatted_memories}"
 
 
+    def build_context_for_task(self, query: str = None) -> str:
+        """
+        Automatically builds a minimal, highly relevant set of contextual information for a given task.
+        """
+        if not query:
+            return ""
+
+        query = self._sanitize_query(query=query)
+
+        context = []
+        context.append(self._fetch_stm_context(query))
+        context.append(self._fetch_ltm_context(query))
+        if self.memory_provider == "mem0":
+            context.append(self._fetch_user_context(query))
+        return "\n".join(filter(None, context))
+
+
     # def _fetch_entity_context(self, query) -> str:
     #     """
     #     Fetches relevant entity information from Entity Memory related to the task's description and expected_output,

{versionhq-1.2.2.1 → versionhq-1.2.2.3}/src/versionhq/storage/ltm_sqlite_storage.py

@@ -97,7 +97,7 @@ class LTMSQLiteStorage:
                     ]
 
         except sqlite3.Error as e:
-            self._logger.log(level="error", message=f"MEMORY ERROR: An error occurred while querying LTM: {e}",color="red")
+            self._logger.log(level="error", message=f"MEMORY ERROR: An error occurred while querying LTM: {str(e)}",color="red")
             return None
 
 

{versionhq-1.2.2.1 → versionhq-1.2.2.3}/src/versionhq/task/evaluation.py

@@ -103,7 +103,7 @@ class Evaluation(BaseModel):
                 new_res = filter(lambda x: "score" in x["metadata"], res)
                 new_res = list(new_res)
                 new_res.sort(key=lambda x: x["metadata"]["score"], reverse=True)
-                if new_res[0]['data']:
+                if new_res and new_res[0]['data']:
                     c = new_res[0]['data']['task_output']
                     w = new_res[len(new_res)-1]['data']['task_output'] if new_res[len(new_res)-1]['metadata']['score'] < new_res[0]['metadata']['score'] else ""
                     shot_prompt = SHOTS.format(c=c, w=w)

{versionhq-1.2.2.1 → versionhq-1.2.2.3}/src/versionhq/task_graph/model.py

@@ -8,14 +8,63 @@ import matplotlib.pyplot as plt
 from abc import ABC
 from concurrent.futures import Future
 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.agent.model import Agent
-from versionhq.task.model import Task, TaskOutput
+from versionhq.task.model import Task, TaskOutput, Evaluation
 from versionhq._utils.logger import Logger
 
+class ConditionType(enum.Enum):
+    AND = 1
+    OR = 2
+
+
+class Condition(BaseModel):
+    """
+    A Pydantic class to store edge conditions and their args and types.
+    """
+    # edge_id: UUID4 = uuid.uuid4()
+    methods: Dict[str, Callable | "Condition"] = dict()
+    args: Dict[str, Dict[str, Any]] = dict()
+    type: ConditionType = None
+
+    @model_validator(mode="after")
+    def validate_type(self) -> Self:
+        if len(self.methods.keys()) > 1 and self.type is None:
+            raise PydanticCustomError("missing_type", "Missing type", {})
+        return self
+
+    def _execute_method(self, key: str, method: Callable | "Condition") -> bool:
+        match method:
+            case Condition():
+                return method.condition_met()
+            case _:
+                args = self.args[key] if key in self.args else None
+                res = method(**args) if args else method()
+                return res
+
+
+    def condition_met(self) -> bool:
+        if not self.methods:
+            return True
+
+        if len(self.methods) == 1:
+            for k, v in self.methods.items():
+               return self._execute_method(key=k, method=v)
+
+        else:
+            cond_list = []
+            for k, v in self.methods.items():
+                res = self._execute_method(key=k, method=v)
+                if self.type == ConditionType.OR and res == True:
+                    return True
+                elif self.type == ConditionType.AND and res == False:
+                    return False
+            return bool(len([item for item in cond_list if item == True]) == len(cond_list))
+
 
 class TaskStatus(enum.Enum):
     """
@@ -52,7 +101,6 @@ class Node(BaseModel):
     assigned_to: InstanceOf[Agent] = Field(default=None)
     status: TaskStatus = Field(default=TaskStatus.NOT_STARTED)
 
-
     @field_validator("id", mode="before")
     @classmethod
     def _deny_user_set_id(cls, v: Optional[UUID4]) -> None:
@@ -83,7 +131,6 @@ class Node(BaseModel):
         self.status = TaskStatus.COMPLETED if res else TaskStatus.ERROR
         return res
 
-
     @property
     def in_degrees(self) -> int:
         return len(self.in_degree_nodes) if self.in_degree_nodes else 0
@@ -101,6 +148,11 @@ class Node(BaseModel):
         """Unique identifier of the node"""
         return f"{str(self.id)}"
 
+    @property
+    def label(self) -> str:
+        """Human friendly label for visualization"""
+        return self.task.name if self.task.name else self.task.description[0: 8]
+
     def __str__(self):
         if self.task:
             return f"{self.identifier}: {self.task.name if self.task.name else self.task.description[0: 12]}"
@@ -110,19 +162,17 @@ class Node(BaseModel):
 
 class Edge(BaseModel):
     """
-    A class to store an edge object that connects source and target nodes.
+    A Pydantic 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)")
-
+    weight: Optional[float | int] = Field(default=1, description="est. duration of the task execution or respective weight of the target node at any scale i.e., 1 low - 10 high priority")
     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)
+    condition: Optional[Condition] = Field(default=None)
 
     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")
@@ -150,35 +200,36 @@ class Edge(BaseModel):
         False	Given	Condition True (predecessor status irrelevant)	Yes
         """
 
-        if not self.required:
-            return self.condition(**self.condition_kwargs) if self.condition else True
+        if self.required == False:
+            return self.condition.condition_met() if self.condition else True
+            # 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 not self.source or self.source.status == TaskStatus.COMPLETED:
-                    return self.condition(**self.conditon_kwargs) if self.condition else True
+                    return self.condition.condition_met() if self.condition else True
                 else:
                     return False
 
             case DependencyType.START_TO_START:
                 """target starts when source starts"""
                 if not self.source or self.source.status != TaskStatus.NOT_STARTED:
-                    return self.condition(**self.conditon_kwargs) if self.condition else True
+                    return self.condition.condition_met() if self.condition else True
                 else:
                     return False
 
             case DependencyType.FINISH_TO_FINISH:
                 """target finish when source start"""
                 if not self.source or self.source.status != TaskStatus.COMPLETED:
-                    return self.condition(**self.conditon_kwargs) if self.condition else True
+                    return self.condition.condition_met() if self.condition else True
                 else:
                     return False
 
             case DependencyType.START_TO_FINISH:
                 """target finishes when source start"""
                 if not self.source or self.source.status == TaskStatus.IN_PROGRESS:
-                    return self.condition(**self.conditon_kwargs) if self.condition else True
+                    return self.condition.condition_met() if self.condition else True
                 else:
                     return False
 
@@ -204,6 +255,11 @@ class Edge(BaseModel):
         res = self.target.handle_task_execution(context=context, response_format=response_format)
         return res
 
+    @property
+    def label(self):
+        """Human friendly label for visualization."""
+        return f"e{self.source.label}-{self.target.label}"
+
 
 class Graph(ABC, BaseModel):
     """
@@ -383,7 +439,7 @@ class TaskGraph(Graph):
         edge = Edge()
         for k in Edge.model_fields.keys():
             v = edge_attributes.get(k, None)
-            if v:
+            if v is not None:
                 setattr(edge, k, v)
             else:
                 pass
@@ -564,7 +620,7 @@ class TaskGraph(Graph):
             return res, self.outputs
 
 
-    def evaluate(self, eval_criteria: List[str] = None):
+    def evaluate(self, eval_criteria: List[str] = None) -> Evaluation | None:
         """Evaluates the conclusion based on the given eval criteria."""
 
         if not isinstance(self.concl, TaskOutput):

{versionhq-1.2.2.1 → versionhq-1.2.2.3}/src/versionhq.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: versionhq
-Version: 1.2.2.1
+Version: 1.2.2.3
 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.2.3/tests/task_graph/task_graph_test.py

@@ -0,0 +1,88 @@
+from unittest.mock import patch
+
+
+def test_draft():
+    import versionhq as vhq
+    from pydantic import BaseModel
+
+    class Trip(BaseModel):
+        name: str
+        location: str
+        description: str
+        date: str
+        cousine: str
+        why_its_suitable: str
+
+
+    with patch('builtins.input', return_value='Y'):
+        task_graph = vhq.workflow(
+            Trip,
+            context="Planning a suprise day trip for my friend to celebrate her birthday. We live in CA and we like to have Korean food.",
+            human=True
+        )
+
+        assert task_graph
+        assert [k == node.identifier and node.task and isinstance(node, vhq.Node) for k, node in task_graph.nodes.items()]
+        assert [isinstance(edge.dependency_type, vhq.DependencyType) and isinstance(edge, vhq.Edge) for k, edge in task_graph.edges.items()]
+        assert [k in task_graph.nodes.keys() and v.status == vhq.TaskStatus.NOT_STARTED for k, v in task_graph.nodes.items()]
+
+
+def test_condition():
+    import versionhq as vhq
+
+    task_a = vhq.Task(description="draft a message")
+    task_b = vhq.Task(description="ask human for feedback")
+    task_c = vhq.Task(description="send a message")
+
+    tg = vhq.TaskGraph(directed=True)
+
+    node_a = tg.add_task(task=task_a)
+    node_b = tg.add_task(task=task_b)
+    node_c = tg.add_task(task=task_c)
+
+    def cond_method(): return True
+
+    def cond_method_with_args(**kwargs):
+        item = kwargs.get("item", None)
+        return True if item else False
+
+    complex_condition = vhq.Condition(
+        methods={"0": cond_method, "1": cond_method_with_args, "2": cond_method_with_args},
+        args={"2": dict(item="Hi!"), },
+        type=vhq.ConditionType.AND
+    )
+
+    tg.add_dependency(
+        node_a.identifier, node_b.identifier,
+        dependency_type=vhq.DependencyType.FINISH_TO_START,
+        required=False,
+        condition=vhq.Condition(methods={ "0": cond_method, }),
+    )
+
+    edge = [v for v in tg.edges.values()][0]
+    assert isinstance(edge, vhq.Edge)
+    assert edge.required == False
+    assert edge.dependency_type == vhq.DependencyType.FINISH_TO_START
+    assert edge.condition == vhq.Condition(methods={ "0": cond_method, })
+    assert edge.dependency_met() == True
+
+
+    tg.add_dependency(
+        node_b.identifier, node_c.identifier,
+        dependency_type=vhq.DependencyType.FINISH_TO_START,
+        required=False,
+        condition=vhq.Condition(
+            methods={ "0": cond_method, "1": cond_method_with_args, "2": complex_condition },
+            type=vhq.ConditionType.AND
+        ),
+    )
+
+    edge = [v for v in tg.edges.values()][1]
+    assert isinstance(edge, vhq.Edge)
+    assert edge.required == False
+    assert edge.dependency_type == vhq.DependencyType.FINISH_TO_START
+    assert edge.condition == vhq.Condition(
+        methods={ "0": cond_method, "1": cond_method_with_args, "2": complex_condition },
+        type=vhq.ConditionType.AND
+    )
+    assert edge.dependency_met() == False

{versionhq-1.2.2.1 → versionhq-1.2.2.3}/tests/usecase_test.py

@@ -55,3 +55,18 @@ def test_demo_agent_customization():
     assert agent.llm.temperature == 1 and agent.llm.top_p == 0.1 and agent.llm.n == 1 and agent.llm.stop == "test"
     assert agent.knowledge_sources == ['https://business.linkedin.com', f'{current_path}/demo.csv',]
     assert agent.with_memory == True
+
+
+def test_solo_tg_eval():
+    import versionhq as vhq
+
+    network = vhq.form_agent_network(
+        task="test",
+        expected_outcome="test"
+    )
+
+    res, tg = network.launch()
+    eval = tg.evaluate(
+        eval_criteria=["cost", "", "{criteria_3}"]
+    )
+    assert isinstance(eval, vhq.Evaluation)