versionhq 1.2.2.2__py3-none-any.whl → 1.2.2.4__py3-none-any.whl

versionhq/__init__.py

@@ -17,10 +17,11 @@ 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
+from versionhq.tool.rag_tool import RagTool
 from versionhq.tool.cache_handler import CacheHandler
 from versionhq.tool.tool_handler import ToolHandler
 from versionhq.tool.composio_tool import ComposioHandler
@@ -31,7 +32,7 @@ from versionhq.agent_network.formation import form_agent_network
 from versionhq.task_graph.draft import workflow
 
 
-__version__ = "1.2.2.2"
+__version__ = "1.2.2.4"
 __all__ = [
     "Agent",
 
@@ -67,6 +68,8 @@ __all__ = [
     "Node",
     "Edge",
     "DependencyType",
+    "Condition",
+    "ConditionType",
 
     "Task",
     "TaskOutput",
@@ -78,6 +81,7 @@ __all__ = [
 
     "Tool",
     "ToolSet",
+    "RagTool",
     "CacheHandler",
     "ToolHandler",
     "ComposioHandler",

versionhq/_utils/llm_as_a_judge.py

@@ -0,0 +1,65 @@
+import json
+import numpy as np
+from sklearn.metrics import precision_score, recall_score, roc_auc_score, cohen_kappa_score
+from typing import List, Tuple, Dict, Any
+from pathlib import Path
+
+
+class LLMJudge:
+
+    class MockLLM:
+        def _generate(self, prompt: str) -> str:
+            return str(np.random.random())
+
+
+    def __init__(self, model: MockLLM = None):
+        self.model = model if model else self.MockLLM()
+
+
+    def judge_summary(self, original_text: str, summary: str) -> float:
+        prompt = f"""Evaluate the quality of the following summary on a scale of 0 to 1, where 0 is poor and 1 is excellent.
+Consider accuracy, completeness, and conciseness.
+Original text: {original_text}
+Summary: {summary}
+Quality score:"""
+        response = self.model._generate(prompt)
+        score = float(response.strip())
+        return score
+
+
+def generate_summaries(file_path: str, data: List[Dict[str, Any]] = None, summarizer: Any = None) -> List[Tuple[str, str, float]]:
+    """Generates a list of tuple with an original text, summary text, and human judge score."""
+    if not data:
+        with open(file_path, 'r') as file:
+            data = json.load(file)
+    summaries = []
+    for item in data:
+        original_text = item['text']
+        summary = summarizer.summarize(original_text)
+        human_score = item['human_score']
+        summaries.append((original_text, summary, human_score))
+
+    return summaries
+
+
+def validate(judge: LLMJudge, data: List[Tuple[str, str, float]], threshold: float = 0.5):
+    human_scores = []
+    predicted_scores = []
+
+    for original_text, summary, human_score in data:
+        predicted_score = judge.judge_summary(original_text=original_text, summary=summary)
+        human_scores.append(human_score)
+        predicted_scores.append(predicted_score)
+
+    human_binary = [1 if score >= threshold else 0 for score in human_scores]
+    pred_binary = [1 if score >= threshold else 0 for score in predicted_scores]
+    precision = precision_score(human_binary, pred_binary, zero_division=0)
+    recall = recall_score(human_binary, pred_binary, zero_division=0)
+    auroc = roc_auc_score(human_binary, pred_binary, average='weighted')
+    kappa = cohen_kappa_score(human_binary, pred_binary)
+    return {
+        "precision": precision,
+        "recall": recall,
+        "auroc": auroc,
+        "cohen_kappa": kappa
+    }

versionhq/agent/model.py

@@ -8,7 +8,7 @@ from pydantic import UUID4, BaseModel, Field, InstanceOf, PrivateAttr, model_val
 from pydantic_core import PydanticCustomError
 
 from versionhq.llm.model import LLM, DEFAULT_CONTEXT_WINDOW_SIZE, DEFAULT_MODEL_NAME, PROVIDERS
-from versionhq.tool.model import Tool, ToolSet
+from versionhq.tool.model import Tool, ToolSet, BaseTool
 from versionhq.knowledge.model import BaseKnowledgeSource, Knowledge
 from versionhq.memory.contextual_memory import ContextualMemory
 from versionhq.memory.model import ShortTermMemory, LongTermMemory, UserMemory
@@ -39,7 +39,7 @@ class Agent(BaseModel):
     goal: str = Field(description="concise goal of the agent (details are set in the Task instance)")
     backstory: Optional[str] = Field(default=None, description="developer prompt to the llm")
     skillsets: Optional[List[str]] = Field(default_factory=list)
-    tools: Optional[List[InstanceOf[Tool | ToolSet] | Type[Tool] | Any]] = Field(default_factory=list)
+    tools: Optional[List[Any]] = Field(default_factory=list)
 
     # knowledge
     knowledge_sources: Optional[List[BaseKnowledgeSource | Any]] = Field(default=None)
@@ -122,29 +122,41 @@ class Agent(BaseModel):
         """
         Similar to the LLM set up, when the agent has tools, we will declare them using the Tool class.
         """
-        if not self.tools:
-            pass
+        from versionhq.tool.rag_tool import RagTool
 
-        else:
-            tool_list = []
+        if not self.tools:
+            return self
 
-            for item in self.tools:
-                if isinstance(item, Tool) or isinstance(item, ToolSet):
+        tool_list = []
+        for item in self.tools:
+            match item:
+                case RagTool() | BaseTool():
                     tool_list.append(item)
 
-                elif isinstance(item, dict) and "func" in item:
-                    tool = Tool(**item)
-                    tool_list.append(tool)
+                case Tool():
+                    if item.func is not None:
+                        tool_list.append(item)
 
-                elif type(item) is Tool and hasattr(item, "func"):
-                    tool_list.append(item)
+                case ToolSet():
+                    if item.tool and item.tool.func is not None:
+                        tool_list.append(item)
 
-                else:
-                    Logger(**self.loger_config, filename=self.key).log(level="error", message=f"Tool {str(item)} is missing a function.", color="red")
-                    raise PydanticCustomError("invalid_tool", f"The tool {str(item)} is missing a function.", {})
+                case dict():
+                    if "func" in item:
+                        tool = Tool(func=item["func"])
+                        for k, v in item.items():
+                            if k in Tool.model_fields.keys() and k != "func" and  v is not None:
+                                setattr(tool, k, v)
+                        tool_list.append(tool)
 
-            self.tools = tool_list
+                case _:
+                    if item.__base__ == BaseTool or item.__base__ == RagTool or item.__base__ == Tool:
+                        tool_list.append(item)
+                    else:
+                        Logger(**self._logger_config, filename=self.key).log(level="error", message=f"Tool {str(item)} is missing a function.", color="red")
+                        raise PydanticCustomError("invalid_tool", f"The tool {str(item)} is missing a function.", {})
 
+        self.tools = tool_list
         return self
 
 
@@ -158,7 +170,7 @@ class Agent(BaseModel):
             from versionhq.agent.TEMPLATES.Backstory import BACKSTORY_FULL, BACKSTORY_SHORT
             backstory = ""
             skills = ", ".join([item for item in self.skillsets]) if self.skillsets else ""
-            tools = ", ".join([item.name for item in self.tools if hasattr(item, "name")]) if self.tools else ""
+            tools = ", ".join([item.name for item in self.tools if hasattr(item, "name") and item.name is not None]) if self.tools else ""
             role = self.role.lower()
             goal = self.goal.lower()
 
@@ -199,7 +211,7 @@ class Agent(BaseModel):
                     if isinstance(item, BaseKnowledgeSource):
                         knowledge_sources.append(item)
 
-                    elif isinstance(item, str) and "http" in item:
+                    elif isinstance(item, str) and "http" in item and DoclingSource._validate_url(url=item) == True:
                         docling_fp.append(item)
 
                     elif isinstance(item, str):
@@ -223,8 +235,8 @@ class Agent(BaseModel):
 
                 self._knowledge = Knowledge(sources=knowledge_sources, embedder_config=self.embedder_config, collection_name=collection_name)
 
-            except:
-                Logger(**self._logger_config, filename=self.key).log(level="warning", message="We cannot find the format for the source. Add BaseKnowledgeSource objects instead.", color="yellow")
+            except Exception as e:
+                Logger(**self._logger_config, filename=self.key).log(level="warning", message=f"We cannot find the format for the source. Add BaseKnowledgeSource objects instead. {str(e)}", color="yellow")
 
         return self
 
@@ -506,10 +518,13 @@ class Agent(BaseModel):
         """
 
         from versionhq.task.model import Task
+        from versionhq.tool.rag_tool import RagTool
         from versionhq.knowledge._utils import extract_knowledge_context
 
         task: InstanceOf[Task] = task
-        tools: Optional[List[InstanceOf[Tool | ToolSet] | Type[Tool]]] = task_tools + self.tools if task.can_use_agent_tools else task_tools
+        all_tools: Optional[List[Tool | ToolSet | RagTool | Type[BaseTool]]] = task_tools + self.tools if task.can_use_agent_tools else task_tools
+        rag_tools: Optional[List[RagTool]] = [item for item in all_tools if isinstance(item, RagTool)] if all_tools else None
+        tools: Optional[List[Tool | ToolSet | RagTool | Type[BaseTool]]] = [item for item in all_tools if not isinstance(item, RagTool)] if all_tools else None
 
         if self.max_rpm and self._rpm_controller:
             self._rpm_controller._reset_request_count()
@@ -523,6 +538,12 @@ class Agent(BaseModel):
                 if agent_knowledge_context:
                     task_prompt += agent_knowledge_context
 
+        if rag_tools:
+            for item in rag_tools:
+                rag_tool_context = item.run(agent=self, query=task.description)
+                if rag_tool_context:
+                    task_prompt += ",".join(rag_tool_context) if isinstance(rag_tool_context, list) else str(rag_tool_context)
+
         if self.with_memory == True:
             contextual_memory = ContextualMemory(
                 memory_config=self.memory_config, stm=self.short_term_memory, ltm=self.long_term_memory, um=self.user_memory
@@ -533,7 +554,6 @@ class Agent(BaseModel):
             if memory.strip() != "":
                 task_prompt += memory.strip()
 
-
         ## comment out for now
         # if self.networks and self.networks._train:
         #     task_prompt = self._training_handler(task_prompt=task_prompt)

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
 
 
@@ -277,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,
@@ -284,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/knowledge/source_docling.py

@@ -83,7 +83,8 @@ class DoclingSource(BaseKnowledgeSource):
             yield chunk.text
 
 
-    def _validate_url(self, url: str) -> bool:
+    @staticmethod
+    def _validate_url(url: str) -> bool:
         try:
             result = urlparse(url)
             return all(

versionhq/knowledge/storage.py

@@ -125,7 +125,8 @@ class KnowledgeStorage(BaseKnowledgeStorage):
     def search(self, query: List[str], limit: int = 3, filter: Optional[dict] = None, score_threshold: float = 0.35) -> List[Dict[str, Any]]:
         with suppress_logging():
             if self.collection:
-                fetched = self.collection.query(query_texts=query, n_results=limit, where=filter)
+                query_texts = ", ".join(query) if isinstance(query, list) else str(query)
+                fetched = self.collection.query(query_texts=query_texts, n_results=limit, where=filter)
                 results = []
                 for i in range(len(fetched["ids"][0])):
                     result = {

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/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/tool/model.py

@@ -43,7 +43,6 @@ class BaseTool(ABC, BaseModel):
             { "__annotations__": { k: v for k, v in cls._run.__annotations__.items() if k != "return" }},
         )
 
-
     @field_validator("properties", mode="before")
     @classmethod
     def _default_properties(cls, v: Dict[str, Any]) -> Dict[str, Any]:
@@ -81,10 +80,9 @@ class BaseTool(ABC, BaseModel):
         return self
 
     @abstractmethod
-    def _run(self, *args: Any, **kwargs: Any,) -> Any:
+    def _run(self, *args: Any, **kwargs: Any) -> Any:
         """any handling"""
 
-
     @staticmethod
     def _get_arg_annotations(annotation: type[Any] | None) -> str:
         if annotation is None:
@@ -143,11 +141,9 @@ class BaseTool(ABC, BaseModel):
         return create_model(schema_name, **fields)
 
 
-
 class Tool(BaseTool):
     func: Callable = Field(default=None)
 
-
     @model_validator(mode="after")
     def validate_func(self) -> Self:
         if not self.func and not self._run:

versionhq/tool/rag_tool.py

@@ -0,0 +1,112 @@
+import re
+import requests
+import html2text
+import gzip
+import http.client
+import urllib.request
+from urllib.request import Request
+from textwrap import dedent
+from typing import Any, Optional, List, Dict
+
+from pydantic import Field
+
+from versionhq.agent.model import Agent
+from versionhq.tool.model import BaseTool
+from versionhq._utils.logger import Logger
+
+
+
+class RagTool(BaseTool):
+    """A Pydantic class to store a RAG tool object. Inherited from BaseTool"""
+
+    api_key_name: str = Field(default=None)
+    api_endpoint: Optional[str] = Field(default=None)
+
+    url: Optional[str] = Field(default=None, description="url to scrape")
+    headers: Optional[Dict[str, Any]] = Field(default_factory=dict, description="request headers")
+
+    sources: Optional[List[Any]] = Field(default_factory=list, description="indexed data sources")
+    query: Optional[str] = Field(default=None)
+    text: Optional[str] = Field(default=None, description="text data source")
+
+
+    def _sanitize_source_code(self, source_code: str | bytes = None) -> str | None:
+        if not source_code:
+            return None
+
+        if isinstance(source_code, bytes):
+            source_code = source_code.decode('utf-8')
+
+        h = html2text.HTML2Text()
+        h.ignore_links = False
+        text = h.handle(source_code)
+        text = re.sub(r"[^a-zA-Z$0-9\s\n]", "", text)
+        return dedent(text)
+
+
+    def _scrape_url(self, url: str = None) -> str | None:
+        url = url if url else self.url
+
+        if not url:
+            return None
+
+        http.client.HTTPConnection.debuglevel = 1
+
+        try:
+            req = Request(url=url, headers=self.headers, origin_req_host=url, method="GET")
+            res = ""
+
+            with urllib.request.urlopen(req) as url:
+                if url.info().get("Content-Encoding") == "gzip":
+                    res = gzip.decompress(url.read())
+                else:
+                    res = url.read()
+
+            text = self._sanitize_source_code(source_code=res)
+            return text
+
+        except requests.exceptions.HTTPError as e:
+            Logger().log(level="error", message=f"HTTP error occurred: {str(e)}", color="red")
+            return None
+
+        except Exception as e:
+            Logger().log(level="error", message=f"Error fetching URL {self.api_endpoint}: {str(e)}", color="red")
+            return None
+
+
+    def store_data(self, agent: Agent = None) -> None:
+        """Stores retrieved data in the storage"""
+        if not agent:
+            return
+
+        text = self.text if self.text else self._scrape_url(self.url)
+        self.text = text
+        knowledge_sources = [*agent.knowledge_sources, str(text), ] if agent.knowledge_sources else [str(text),]
+        agent.update(knowledge_sources=knowledge_sources)
+
+
+    def _run(self, agent: Agent = None, query: str = None) -> List[str]:
+        query = query if query else self.query
+
+        if not query or not agent:
+            text = self.text if self.text else self._scrape_url(self.url)
+            self.text = text
+            return [text,]
+
+        else:
+            results, res = [], []
+            if agent._knowledge:
+                res = agent._knowledge.query(query=[query], limit=5)
+            else:
+                self.store_data(agent=agent)
+                res = agent._knowledge.query(query=[query], limit=5)
+
+            for item in res:
+                if isinstance(item, dict):
+                    results.append(item["context"])
+                else:
+                    results.append(str(item))
+            return results
+
+    def run(self, *args, **kwargs):
+        return self._run(*args, **kwargs)

{versionhq-1.2.2.2.dist-info → versionhq-1.2.2.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: versionhq
-Version: 1.2.2.2
+Version: 1.2.2.4
 Summary: An agentic orchestration framework for building agent networks that handle task automation.
 Author-email: Kuriko Iwai <kuriko@versi0n.io>
 License: MIT License
@@ -50,7 +50,7 @@ Requires-Dist: werkzeug>=3.1.3
 Requires-Dist: typing
 Requires-Dist: json-repair
 Requires-Dist: litellm>=1.55.8
-Requires-Dist: openai>=1.57.0
+Requires-Dist: openai>=1.64.0
 Requires-Dist: composio-openai>=0.6.9
 Requires-Dist: composio>=0.1.0
 Requires-Dist: setuptools>=75.6.0
@@ -69,7 +69,7 @@ Requires-Dist: matplotlib>=3.10.0
 Provides-Extra: docling
 Requires-Dist: docling>=2.17.0; extra == "docling"
 Provides-Extra: mem0ai
-Requires-Dist: mem0ai>=0.1.48; extra == "mem0ai"
+Requires-Dist: mem0ai>=0.1.55; extra == "mem0ai"
 Provides-Extra: pdfplumber
 Requires-Dist: pdfplumber>=0.11.5; extra == "pdfplumber"
 Provides-Extra: pandas
@@ -78,6 +78,11 @@ Provides-Extra: numpy
 Requires-Dist: numpy>=1.26.4; extra == "numpy"
 Provides-Extra: pygraphviz
 Requires-Dist: pygraphviz>=1.14; extra == "pygraphviz"
+Provides-Extra: tools
+Requires-Dist: html2text>=2024.2.26; extra == "tools"
+Requires-Dist: sec-api>=1.0.28; extra == "tools"
+Provides-Extra: eval
+Requires-Dist: scikit-learn>=1.6.1; extra == "eval"
 
 # Overview
 

{versionhq-1.2.2.2.dist-info → versionhq-1.2.2.4.dist-info}/RECORD

@@ -1,20 +1,21 @@
-versionhq/__init__.py,sha256=vGvxfqX6PuindBNVOX_OoewD27MqktESYpdzvLvkX_U,2857
+versionhq/__init__.py,sha256=PqOgmog9JVNxGm2LP1RV5x3D-U7PClfcKFWVAE6dXCM,2980
 versionhq/_utils/__init__.py,sha256=d-vYVcORZKG-kkLe_fzE8VbViDpAk9DDOKe2fVK25ew,178
 versionhq/_utils/i18n.py,sha256=TwA_PnYfDLA6VqlUDPuybdV9lgi3Frh_ASsb_X8jJo8,1483
+versionhq/_utils/llm_as_a_judge.py,sha256=RM0oYfoeanuUyUL3Ewl6_8Xn1F5Axd285UMH46kxG1I,2378
 versionhq/_utils/logger.py,sha256=iHxGjm3BvUo5dHKLU88_pc0Z45wzSHOjyJGQkb7OADk,3255
 versionhq/_utils/process_config.py,sha256=YTGY_erW335RfceQfzS18YAqq-AAb-iSvKSjN7noD2E,782
 versionhq/_utils/usage_metrics.py,sha256=xgYGRW3OTuK9EJyi3QYJeYcJl7dL27olcWaLo_7B3JE,2246
 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=WAbyog-6pKwa8ru9u_KJgD_ViTLv4ZRECks1Znch47E,2638
-versionhq/agent/model.py,sha256=cYplMaQXHocFeZGZ1WIZ5npZ_Edokj3qFPBE9PiBxHw,25285
+versionhq/agent/model.py,sha256=xebClhCdx0Xt-_or3Ne_fTh8eOWSDEbi4r3WvGSOYcI,26595
 versionhq/agent/parser.py,sha256=riG0dkdQCxH7uJ0AbdVdg7WvL0BXhUgJht0VtQvxJBc,4082
 versionhq/agent/rpm_controller.py,sha256=grezIxyBci_lDlwAlgWFRyR5KOocXeOhYkgN02dNFNE,2360
 versionhq/agent/TEMPLATES/Backstory.py,sha256=IAhGnnt6VUMe3wO6IzeyZPDNu7XE7Uiu3VEXUreOcKs,532
 versionhq/agent/TEMPLATES/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/agent_network/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/agent_network/formation.py,sha256=CYKNUeKC392wW3leIDIAaGiKADSsumC_vTe0VOnNwRs,7901
-versionhq/agent_network/model.py,sha256=lr63cmH7ecQrfVAtnN44mtijrnOsfKe-8xOVNBXv-3Q,15696
+versionhq/agent_network/model.py,sha256=aSGZf-ZLi4I2Da9-RW8CfZ32hk9MN_RIT9Cl4xvHlE8,16050
 versionhq/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/clients/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/clients/customer/__init__.py,sha256=-YXh1FQfvpfLacK8SUC7bD7Wx_eIEi4yrkCC_cUasFg,217
@@ -28,8 +29,8 @@ versionhq/knowledge/_utils.py,sha256=YWRF8U533cfZes_gZqUvdj-K24MD2ri1R0gjc_aPYyc
 versionhq/knowledge/embedding.py,sha256=KfHc__1THxb5jrg1EMrF-v944RDuIr2hE0l-MtM3Bp0,6826
 versionhq/knowledge/model.py,sha256=ixH8n5kLtJEp1nPAFYA0piYm-n0nnFDtWFp0r9YEVAs,1787
 versionhq/knowledge/source.py,sha256=-hEUPtJUHHMx4rUKtiHl19J8xAMw-WVBw34zwa2jZ08,13630
-versionhq/knowledge/source_docling.py,sha256=OUdWUZ6CCaddvmOKNYpYVzXCzqy9kwuTqsl0supT6GI,5429
-versionhq/knowledge/storage.py,sha256=7oxCg3W9mFjYH1YmuH9kFtTbNxquzYFjuUjd_TlsB9E,8170
+versionhq/knowledge/source_docling.py,sha256=dcu1ITqPXwWZ_lK-6tykEKhhC82eNRTMoWRpxK9Kzls,5441
+versionhq/knowledge/storage.py,sha256=Kd-4r6aWM5EDaoXrzKXbgi1hY6tysSQARPGXM95qMmU,8266
 versionhq/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/llm/llm_vars.py,sha256=wjQK20cKvph6Vq1v71o4d16zBGcHlwq0bzOT_zWno7w,7041
 versionhq/llm/model.py,sha256=HIBmf8FYV6-cDbZK1ZBu6z3dmF0ZUbKbCelfwxMlgyY,17177
@@ -44,7 +45,7 @@ versionhq/storage/rag_storage.py,sha256=bS2eE874obarYl-4hT6ZWYWTRsqtfuGpKgKzERmM
 versionhq/storage/task_output_storage.py,sha256=M8vInLJ5idGAq17w1juHKXtyPyF-B-rK_P8UcqD-Px8,5357
 versionhq/storage/utils.py,sha256=r5ghA_ktdR2IuzlzKqZYCjsNxztEMzyhWLneA4cFuWY,748
 versionhq/task/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-versionhq/task/evaluation.py,sha256=mHLNabuvSbi9FGfblomr41vlc3quTHsugH3-3qQmcDw,4461
+versionhq/task/evaluation.py,sha256=iRLzppqwKaiGpbsr9gMbf6T7NQe6rxTA6OBcWhmiCKs,4473
 versionhq/task/formatter.py,sha256=N8Kmk9vtrMtBdgJ8J7RmlKNMdZWSmV8O1bDexmCWgU0,643
 versionhq/task/model.py,sha256=8qBxRgqMs_b8IZA45_gAU1uc5S5w9hdnyRG-Vwm8bVM,28901
 versionhq/task/structured_response.py,sha256=4q-hQPu7oMMHHXEzh9YW4SJ7N5eCZ7OfZ65juyl_jCI,5000
@@ -52,16 +53,17 @@ versionhq/task/TEMPLATES/Description.py,sha256=EkwJHc65G32MjWyn3rcp0ATmMaVPHuYKa
 versionhq/task_graph/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/task_graph/colors.py,sha256=naJCx4Vho4iuJtbW8USUXb-M5uYvd5ds2p8qbjUfRus,669
 versionhq/task_graph/draft.py,sha256=l18XacRsbDhAv6CvKMnUMI26IDuizA1UNWHbL1q5gn4,5099
-versionhq/task_graph/model.py,sha256=53D_Bd-Uz6fv5Y1iVVDX1wzqcabE1BmLzqEO0oL8wrs,24628
+versionhq/task_graph/model.py,sha256=3DzZXP4SSJP3xdgZfkJDgFXUjQ05CSYFoisShfmSdcs,26582
 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=IATfsEnF_1RPJyGtPBmAtEJh5XPcgDHpyG3SUR461Og,8572
 versionhq/tool/composio_tool_vars.py,sha256=FvBuEXsOQUYnN7RTFxT20kAkiEYkxWKkiVtgpqOzKZQ,1843
 versionhq/tool/decorator.py,sha256=C4ZM7Xi2gwtEMaSeRo-geo_g_MAkY77WkSLkAuY0AyI,1205
-versionhq/tool/model.py,sha256=PO4zNWBZcJhYVur381YL1dy6zqurio2jWjtbxOxZMGI,12194
+versionhq/tool/model.py,sha256=Nc2f9frTK5tH4kh6EeEAk1Fi1w19kEXLOcsBwHCS1a4,12189
+versionhq/tool/rag_tool.py,sha256=qm_nDWs-WyDvrxZeZAL2AkswfUWGPZS4zybz0o6wOFI,3653
 versionhq/tool/tool_handler.py,sha256=2m41K8qo5bGCCbwMFferEjT-XZ-mE9F0mDUOBkgivOI,1416
-versionhq-1.2.2.2.dist-info/LICENSE,sha256=cRoGGdM73IiDs6nDWKqPlgSv7aR4n-qBXYnJlCMHCeE,1082
-versionhq-1.2.2.2.dist-info/METADATA,sha256=XZ5QDEnQP1G4U-VFHBsGKBPvVc4vqZMafEp6rZvj89s,22015
-versionhq-1.2.2.2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-versionhq-1.2.2.2.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
-versionhq-1.2.2.2.dist-info/RECORD,,
+versionhq-1.2.2.4.dist-info/LICENSE,sha256=cRoGGdM73IiDs6nDWKqPlgSv7aR4n-qBXYnJlCMHCeE,1082
+versionhq-1.2.2.4.dist-info/METADATA,sha256=fX-azucXgCg-Fm05snnLT02ttDz5u10xMOaBjGmpkp4,22213
+versionhq-1.2.2.4.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+versionhq-1.2.2.4.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
+versionhq-1.2.2.4.dist-info/RECORD,,