versionhq 1.2.4.3__py3-none-any.whl → 1.2.4.6__py3-none-any.whl

versionhq/task_graph/model.py

@@ -1,30 +1,31 @@
 import matplotlib
 matplotlib.use('agg')
 
-import enum
 import uuid
-import networkx as nx
-import matplotlib.pyplot as plt
+import datetime
+from enum import IntEnum, Enum
 from abc import ABC
 from concurrent.futures import Future
 from typing import List, Any, Optional, Callable, Dict, Type, Tuple
 from typing_extensions import Self
 
+import networkx as nx
+import matplotlib.pyplot as plt
 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, Evaluation
+from versionhq.task.model import Task, TaskOutput, Evaluation, ResponseField
 from versionhq._utils import Logger, UsageMetrics, ErrorType
 
 
-class ReformTriggerEvent(enum.Enum):
+class ReformTriggerEvent(IntEnum):
     USER_INPUT = 1 # ask human
     TEST_TIME_COMPUTATION = 2 # mismatch between actual responses and expected outcome
     ERROR_DETECTION = 3 # response error
 
 
-class ConditionType(enum.Enum):
+class ConditionType(IntEnum):
     AND = 1
     OR = 2
 
@@ -71,7 +72,7 @@ class Condition(BaseModel):
             return bool(len([item for item in cond_list if item == True]) == len(cond_list))
 
 
-class TaskStatus(enum.Enum):
+class TaskStatus(IntEnum):
     """
     Enum to track the task execution status
     """
@@ -84,7 +85,7 @@ class TaskStatus(enum.Enum):
     ERROR = 7       # tried task execute but returned error. resupmtion follows edge weights and agent settings
 
 
-class DependencyType(enum.Enum):
+class DependencyType(str, Enum):
     """
     Concise enumeration of the edge type.
     """
@@ -129,7 +130,7 @@ class Node(BaseModel):
         else:
             self.status = TaskStatus.IN_PROGRESS
             agent = agent if agent else self.assigned_to
-            self.task.pydantic_output = self.task.pydantic_output if self.task.pydantic_output else response_format if type(response_format) == BaseModel else None
+            self.task.response_schema = self.task.response_schema if self.task.response_schema else response_format if type(response_format) == BaseModel or isinstance(response_format, list) else None
             res = self.task.execute(agent=agent, context=context)
 
             if isinstance(res, Future): # activate async
@@ -393,14 +394,13 @@ class Graph(ABC, BaseModel):
 
 
 class TaskGraph(Graph):
-    _usage: Optional[UsageMetrics] = None
-
     id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
     should_reform: bool = False
     reform_trigger_event: Optional[ReformTriggerEvent] = None
     outputs: Dict[str, TaskOutput] = Field(default_factory=dict, description="stores node identifier and TaskOutput")
-    concl_template: Optional[Dict[str, Any] | Type[BaseModel]] = Field(default=None, description="stores final response format in Pydantic class or JSON dict")
+    concl_response_schema: Optional[List[ResponseField] | Type[BaseModel]] = Field(default=None, description="stores final response schema in Pydantic class or response fields")
     concl: Optional[TaskOutput] = Field(default=None, description="stores the final or latest conclusion of the entire task graph")
+    usage: Optional[UsageMetrics] = None
 
 
     def _save(self, title: str, abs_file_path: str = None) -> None:
@@ -420,18 +420,6 @@ class TaskGraph(Graph):
             Logger().log(level="error", message=f"Failed to save the graph {str(self.id)}: {str(e)}", color="red")
 
 
-    def _handle_usage(self) -> None:
-        """Returns total tokens and latency spended for the graph execution."""
-        if not self.nodes:
-            return None
-
-        self._usage = self._usage if self._usage else UsageMetrics(id=self.id)
-
-        for node in self.nodes.values():
-            if node.task and node.task._usage:
-                self._usage.aggregate(metrics=node.task._usage)
-
-
     def _handle_human_input(self) -> str | None:
         """Handles input from human."""
         request = None
@@ -448,12 +436,27 @@ class TaskGraph(Graph):
                 Logger().log(message=f"Ok. regenerating the graph based on your input: ', {request}", level="info", color="blue")
             else:
                 Logger().log(message="Cannot recognize your request.", level="error", color="red")
-                self._usage = self._usage if self._usage else UsageMetrics(id=self.id)
-                self._usage.record_errors(type=ErrorType.HUMAN_INTERACTION)
+                self.usage = self.usage if self.usage else UsageMetrics(id=self.id)
+                self.usage.record_errors(type=ErrorType.HUMAN_INTERACTION)
 
         return request
 
 
+    def _handle_usage(self, start_dt: datetime = None, end_dt: datetime = None) -> UsageMetrics:
+        usage = self.usage if self.usage else UsageMetrics(id=self.id)
+
+        if self.outputs:
+            for item in self.outputs.values():
+                if isinstance(item.usage, UsageMetrics):
+                    usage = usage.aggregate(metrics=item.usage)
+
+        if start_dt and end_dt:
+            usage.record_latency(start_dt, end_dt)
+
+        self.usage = usage
+        return usage
+
+
     def add_task(self, task: Node | Task) -> Node:
         """Convert `task` to a Node object and add it to G"""
 
@@ -596,6 +599,7 @@ class TaskGraph(Graph):
         """
 
         Logger().log(color="blue", message=f"Start to activate the graph: {str(self.id)}", level="info")
+        start_dt = datetime.datetime.now()
 
         if target:
             if not [k for k in self.nodes.keys() if k == target]:
@@ -659,7 +663,6 @@ class TaskGraph(Graph):
                     node_identifier = edge.target.identifier
                     self.outputs.update({ node_identifier: res })
 
-
             if self.should_reform:
                 target = [k for k in self.outputs.keys()][-1] if self.outputs else self.find_start_nodes()[0].identifier if self.find_start_nodes() else None
 
@@ -669,9 +672,10 @@ class TaskGraph(Graph):
                     res, _ = self.handle_reform(target=target)
 
             self.concl = res
-            self.concl_template = self.concl_template if self.concl_template else res.pydantic.__class__ if res.pydantic else None
-             # 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
-            self._handle_usage()
+            self.concl_response_schema = self.concl_response_schema if self.concl_response_schema else res.pydantic.__class__ if res.pydantic else None
+
+            end_dt = datetime.datetime.now()
+            self._handle_usage(start_dt, end_dt)
             return res, self.outputs
 
 

versionhq/tool/{composio_tool.py → composio/model.py}

@@ -7,10 +7,9 @@ from typing_extensions import Self
 
 from pydantic import BaseModel, Field, model_validator, field_validator, UUID4, PrivateAttr
 from pydantic_core import PydanticCustomError
-
 from composio import ComposioToolSet
 
-from versionhq.tool.composio_tool_vars import ComposioAppName, ComposioAuthScheme, composio_app_set, ComposioStatus, ComposioAction
+from versionhq.tool.composio.params import ComposioAppName, ComposioAuthScheme, composio_app_set, ComposioStatus, ComposioAction
 from versionhq.tool.cache_handler import CacheHandler
 from versionhq._utils.logger import Logger
 
@@ -22,7 +21,7 @@ DEFAULT_USER_ID = os.environ.get("DEFAULT_USER_ID", None)
 OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY", None)
 
 
-class ComposioHandler(ABC, BaseModel):
+class ComposioBaseTool(ABC, BaseModel):
     """
     A class to handle connecting account with Composio and executing actions using Composio ecosystem.
     `connected_account_id` is set up per `app_name` to call the actions on the given app. i.e., salesforce
@@ -78,8 +77,8 @@ class ComposioHandler(ABC, BaseModel):
         """
         Composio toolset on LangChain for action execution using LLM.
         """
-        from composio_langchain import ComposioToolSet
-        return ComposioToolSet(api_key=os.environ.get("COMPOSIO_API_KEY"), metadata={**metadata})
+        from composio_langchain import ComposioBaseToolSet
+        return ComposioBaseToolSet(api_key=os.environ.get("COMPOSIO_API_KEY"), metadata={**metadata})
 
 
     def _connect(

versionhq/tool/gpt/__init__.py

@@ -0,0 +1,6 @@
+from dotenv import load_dotenv
+load_dotenv(override=True)
+
+import os
+from openai import OpenAI
+openai_client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))

versionhq/tool/gpt/_enum.py

@@ -0,0 +1,28 @@
+from enum import Enum
+
+
+class GPTSizeEnum(str, Enum):
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+
+
+class GPTCUPEnvironmentEnum(str, Enum):
+    BROWSER = "browser"
+    MAC = "mac"
+    WINDOWS = "windows"
+    UNBUNTU = "ubuntu"
+
+
+class GPTCUPTypeEnum(str, Enum):
+    COMPUTER_CALL_OUTPUT = "computer_call_output"
+    COMPUTER_USE_PREVIEW = "computer_use_preview"
+
+
+class GPTFilterTypeEnum(str, Enum):
+    eq = "eq"
+    ne = "ne"
+    gt = "gt"
+    gte = "gte"
+    lt = "lt"
+    lte = "lte"

versionhq/tool/gpt/cup.py

@@ -0,0 +1,145 @@
+from typing import List, Dict, Any
+
+from versionhq._utils import convert_img_url
+from versionhq.tool.gpt import openai_client
+from versionhq.tool.gpt._enum import GPTCUPEnvironmentEnum, GPTCUPTypeEnum, GPTSizeEnum
+from versionhq._utils import is_valid_enum, UsageMetrics, ErrorType
+
+
+class CUPToolSchema:
+    type: str = GPTCUPTypeEnum.COMPUTER_USE_PREVIEW.value
+    display_width: int = 1024
+    display_height: int = 768
+    environment: str = GPTCUPEnvironmentEnum.BROWSER.value
+
+    def __init__(
+            self,
+            type: str | GPTCUPTypeEnum = None,
+            display_width: int = None,
+            display_height: int = None,
+            environment: str | GPTCUPEnvironmentEnum = None
+        ):
+        self.display_height = display_height if display_height else self.display_height
+        self.display_width = display_width if display_width else self.display_width
+
+        if type and is_valid_enum(enum=GPTCUPTypeEnum, val=type):
+            self.type = type.value if isinstance(type, GPTCUPTypeEnum) else type
+
+        if environment and is_valid_enum(enum=GPTCUPEnvironmentEnum, val=environment):
+            self.environment = environment.value if isinstance(environment, GPTCUPEnvironmentEnum) else environment
+
+        self.environment = environment if environment else self.environment
+
+
+    @property
+    def schema(self) -> Dict[str, Any]:
+        return {
+            "type": self.type if isinstance(self.type, str) else self.type.value,
+            "display_width": self.display_width,
+            "display_height": self.display_height,
+            "environment": self.environment if isinstance(self.environment, str) else self.environment.value,
+        }
+
+
+class GPTToolCUP:
+    model: str = "computer-use-preview"
+    tools: List[CUPToolSchema] = list()
+    user_prompt: str = None
+    img_url: str = None
+    reasoning_effort: str = GPTSizeEnum.MEDIUM.value
+    truncation: str = "auto"
+
+    def __init__(
+        self,
+        user_prompt: str,
+        tools: List[CUPToolSchema] | CUPToolSchema = None,
+        img_url: str = None,
+        reasoning_effort: GPTSizeEnum | str = None,
+        truncation: str = None
+    ):
+        self.user_prompt = user_prompt
+        self.truncation = truncation if truncation else self.truncation
+
+        if img_url:
+            img_url = convert_img_url(img_url)
+            self.img_url = img_url
+
+        if reasoning_effort and is_valid_enum(enum=GPTSizeEnum, val=reasoning_effort):
+            self.reasoning_effort = reasoning_effort.value if isinstance(reasoning_effort, GPTSizeEnum) else reasoning_effort
+
+        if tools:
+            match tools:
+                case list():
+                    if self.tools:
+                        self.tools.extend(tools)
+                    else:
+                        self.tools = tools
+                case CUPToolSchema():
+                    if self.tools:
+                        self.tools.append(tools)
+                    else:
+                        self.tools = [tools]
+                case _:
+                    pass
+
+    def run(self):
+        raw_res = ""
+        usage = UsageMetrics()
+
+        try:
+            res = openai_client.responses.create(**self.schema)
+            if not res:
+                usage.record_errors(ErrorType.TOOL)
+            else:
+                raw_res = res.output[1].summary[0].text
+                usage.record_token_usage(**res.usage.__dict__)
+            return raw_res, None, usage
+        except:
+            usage.record_errors(ErrorType.TOOL)
+            return raw_res, None, usage
+
+
+    @property
+    def schema(self) -> Dict[str, Any]:
+        img_url = convert_img_url(self.img_url)  if self.img_url else None
+        inputs = [{ "role": "user", "content": self.user_prompt } ]
+
+        if img_url:
+            inputs.append({"type": "input_image", "image_url": f"data:image/png;base64,{img_url}"})
+
+        tool_schema = [item.schema for item in self.tools]
+        schema = dict(model=self.model, tools=tool_schema, input=inputs, reasoning={ "effort": self.reasoning_effort}, truncation=self.truncation)
+        return schema
+
+
+#     "output": [
+#     {
+#         "type": "reasoning",
+#         "id": "rs_67cb...",
+#         "summary": [
+#             {
+#                 "type": "summary_text",
+#                 "text": "Exploring 'File' menu option."
+#             }
+#         ]
+#     },
+#     {
+#         "type": "computer_call",
+#         "id": "cu_67cb...",
+#         "call_id": "call_nEJ...",
+#         "action": {
+#             "type": "click",
+#             "button": "left",
+#             "x": 135,
+#             "y": 193
+#         },
+#         "pending_safety_checks": [
+#             {
+#                 "id": "cu_sc_67cb...",
+#                 "code": "malicious_instructions",
+#                 "message": "We've detected instructions that may cause your application to perform malicious or unauthorized actions. Please acknowledge this warning if you'd like to proceed."
+#             }
+#         ],
+#         "status": "completed"
+#     }
+# ]

versionhq/tool/gpt/file_search.py

@@ -0,0 +1,163 @@
+from typing import List, Dict, Any, Optional, Tuple
+
+from versionhq.tool.gpt import openai_client
+from versionhq.tool.gpt._enum import GPTFilterTypeEnum
+from versionhq._utils import is_valid_enum, UsageMetrics, ErrorType
+
+
+def is_valid_vector_store_id(id: str | list[str]) -> bool:
+    if isinstance(id, list):
+        for item in id:
+            if not id.startswith("vs_"):
+                return False
+    else:
+        return id.startswith("vs_")
+
+
+class FilterSchema:
+    class Filter:
+        type: GPTFilterTypeEnum = GPTFilterTypeEnum.eq
+        property: str = None
+        value: str = None
+
+        def __init__(self, **kwargs):
+            for k, v in kwargs:
+                if hasattr(self, k):
+                    setattr(self, k, v)
+
+        def _convert_to_schema(self) -> Dict[str, str] | None:
+            return { "type": self.type, "property": self.property, "value": self.value } if self.property and self.value else None
+
+    logic_type: str = "and"  # or
+    filters: List[Filter] = list()
+    filter_params: Dict[str, Any] = None
+
+    def __init__(self, logic_type: str = None, filters: List[Filter] | Filter = None, filter_params: Dict[str, Any] = None, **kwargs):
+        if logic_type == "and" | "or":
+            self.logic_type = logic_type
+
+        if filter_params:
+            filter = FilterSchema.Filter()
+            for k, v in filter_params.items():
+                if k in FilterSchema.Filter.__dict__.keys():
+                    if k == "type" and is_valid_enum(val=v, enum=GPTFilterTypeEnum):
+                        setattr(filter, k, v if isinstance(v, str) else v.value)
+                    else:
+                        setattr(filter, k, v)
+            self.filters.append(filter)
+
+        if filters:
+            match filters:
+                case list():
+                    if self.filters:
+                        self.filters.extend(filters)
+                    else:
+                        self.filters = filters
+
+                case FilterSchema.Filter():
+                    if self.filters:
+                        self.filters.append(filters)
+                    else:
+                        self.filters = [filters]
+
+                case _:
+                    pass
+
+        if kwargs:
+            for k, v in kwargs:
+                if hasattr(self, k): setattr(self, k, v)
+
+    @property
+    def schema(self) -> Dict[str, Any] | None:
+        if self.type and len(self.items) > 1:
+            return {
+                "type": self.type,
+                "filters": [item._convert_to_schema() for item in self.items if isinstance(item, FilterSchema.Filter)]
+            }
+        elif self.filters:
+            return self.filters[0]._convert_to_schema()
+        else:
+            return None
+
+
+class GPTToolFileSearch:
+    model: str = "gpt-4o"
+    input: str = None
+    vector_store_ids: List[str] = list()
+    max_num_results: int = 2
+    include: List[str] = ["output[*].file_search_call.search_results"]
+    filters: Optional[FilterSchema] = None
+
+    def __init__(
+            self,
+            input: str,
+            vector_store_ids: str | List[str],
+            model: str = None,
+            max_num_results: int = None,
+            include: List[str] = None,
+            filters: FilterSchema | Dict[str, Any] = None,
+            **kwargs,
+        ):
+        if not input or not vector_store_ids:
+            return None
+
+        if not is_valid_vector_store_id(id=vector_store_ids):
+            return None
+
+        self.input = input
+        self.vector_store_ids = vector_store_ids if isinstance(vector_store_ids, list) else [vector_store_ids]
+        self.model = model if model else self.model
+        self.max_num_results = max_num_results if max_num_results else self.max_num_results
+        self.include = include if include else self.include
+        self.filters = filters if filters else None
+        if kwargs:
+            for k, v in kwargs.items():
+                if hasattr(self, k):
+                    setattr(self, k, v)
+
+
+    def run(self) -> Tuple[str, List[Dict[str, Any]], UsageMetrics] | None:
+        raw_res = ""
+        annotations = list()
+        usage = UsageMetrics()
+
+        try:
+            res = openai_client.responses.create(**self.schema)
+            if not res:
+                usage.record_errors(ErrorType.TOOL)
+            else:
+                raw_res = res.output[1].content[0].text
+                annotations = [{ "index": item.index, "file_id": item.file_id, "filename": item.filename }
+                                for item in res.output[1].content[0].annotations]
+                usage.record_token_usage(**res.usage.__dict__)
+            return raw_res, annotations, usage
+        except:
+            usage.record_errors(ErrorType.TOOL)
+            return raw_res, annotations, usage
+
+
+    @property
+    def tool_schema(self) -> Dict[str, Any]:
+        if self.filters:
+            return [
+                {
+                    "type": "file_search",
+                    "vector_store_ids": self.vector_store_ids,
+                    "max_num_results": self.max_num_results,
+                    "filters": self.filters.schema,
+                }
+            ]
+        else:
+            return [
+                {
+                    "type": "file_search",
+                    "vector_store_ids": self.vector_store_ids,
+                    "max_num_results": self.max_num_results,
+                }
+            ]
+
+
+    @property
+    def schema(self) -> Dict[str, Any]:
+        schema = dict(model=self.model, tools=self.tool_schema, input=self.input)
+        return schema

versionhq/tool/gpt/web_search.py

@@ -0,0 +1,89 @@
+from typing import Dict, Any, Optional, Tuple, List
+
+from versionhq.tool.gpt import openai_client
+from versionhq.tool.gpt._enum import GPTSizeEnum
+from versionhq._utils import is_valid_enum, UsageMetrics, ErrorType
+
+
+class GPTToolWebSearch:
+    """A class to manage Web Search tools by OpenAI."""
+
+    model: str = "gpt-4o"
+    input: str = None
+    location_type: str = None  # "approximate"
+    country: str = None  # "GB"
+    city: str = None # "London"
+    region: str = None # "London"
+    search_content_size: str = GPTSizeEnum.MEDIUM.value
+    _user_location: Optional[Dict[str, str]] = None
+
+
+    def __init__(
+            self,
+            model: str = None,
+            input: str = None,
+            location_type: str = None,
+            country: str = None,
+            city: str = None,
+            region: str = None,
+            search_content_size = str | GPTSizeEnum,
+            **kwargs,
+        ):
+        self.model = model if model else self.model
+        self.input = input if input else self.input
+        if country and city and region:
+            self.location_type = location_type if location_type else "approximate"
+            self.country = country
+            self.city = city
+            self.region = region
+            self._user_location = dict(type=self.location_type, country=self.country, city=self.city, region=self.region)
+
+        if is_valid_enum(val=search_content_size, enum=GPTSizeEnum):
+            self.search_content_size = search_content_size if isinstance(search_content_size, str) else search_content_size.value
+
+        if kwargs:
+            for k, v in kwargs.items():
+                if hasattr(self, k):
+                    setattr(self, k, v)
+
+
+    def run(self) -> Tuple[str, List[Dict[str, str]], UsageMetrics]:
+        """Runs the tool and returns text response, annotations, and usage metrics."""
+
+        raw_res = ""
+        annotations = list()
+        usage = UsageMetrics()
+
+        try:
+            res = openai_client.responses.create(**self.schema)
+            if not res:
+                usage.record_errors(ErrorType.TOOL)
+            else:
+                raw_res = res.output[1].content[0].text
+                annotations = [{ "title": item.title, "url": item.url } for item in res.output[1].content[0].annotations]
+                usage.record_token_usage(**res.usage.__dict__)
+            return raw_res, annotations, usage
+        except:
+            usage.record_errors(ErrorType.TOOL)
+            return raw_res, annotations, usage
+
+
+    @property
+    def tool_schema(self) -> Dict[str, Any]:
+        if self._user_location:
+            return {
+                "type": "web_search_preview",
+                "user_location": self._user_location,
+                "search_context_size": self.search_content_size
+            }
+        else:
+            return {
+                "type": "web_search_preview",
+                "search_context_size": self.search_content_size
+            }
+
+
+    @property
+    def schema(self) -> Dict[str, Any]:
+        schema = dict(model=self.model, tools=[self.tool_schema,], input=self.input)
+        return schema

{versionhq-1.2.4.3.dist-info → versionhq-1.2.4.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: versionhq
-Version: 1.2.4.3
+Version: 1.2.4.6
 Summary: Autonomous agent networks for task automation with multi-step reasoning.
 Author-email: Kuriko Iwai <kuriko@versi0n.io>
 License: MIT License
@@ -295,7 +295,7 @@ def dummy_func(message: str, test1: str, test2: list[str]) -> str:
 
 task = vhq.Task(
    description="Amazing task",
-   pydantic_output=CustomOutput,
+   response_schema=CustomOutput,
    callback=dummy_func,
    callback_kwargs=dict(message="Hi! Here is the result: ")
 )
@@ -317,13 +317,13 @@ agent_b = vhq.Agent(role="Leader", llm="gemini-2.0")
 
 task_1 = vhq.Task(
    description="Analyze the client's business model.",
-   response_fields=[vhq.ResponseField(title="test1", data_type=str, required=True),],
+   response_schema=[vhq.ResponseField(title="test1", data_type=str, required=True),],
    allow_delegation=True
 )
 
 task_2 = vhq.Task(
    description="Define a cohort.",
-   response_fields=[vhq.ResponseField(title="test1", data_type=int, required=True),],
+   response_schema=[vhq.ResponseField(title="test1", data_type=int, required=True),],
    allow_delegation=False
 )