versionhq 1.2.4.5__py3-none-any.whl → 1.2.4.7__py3-none-any.whl

versionhq/task/model.py

@@ -3,7 +3,7 @@ import threading
 import datetime
 import uuid
 import inspect
-import enum
+from enum import IntEnum
 from concurrent.futures import Future
 from hashlib import md5
 from typing import Any, Dict, List, Set, Optional, Callable, Type
@@ -14,11 +14,15 @@ from pydantic_core import PydanticCustomError
 
 import versionhq as vhq
 from versionhq.task.evaluation import Evaluation, EvaluationItem
-from versionhq.tool.model import Tool, ToolSet
+from versionhq.tool.model import Tool, ToolSet, BaseTool
+from versionhq.tool.rag_tool import RagTool
+from versionhq.tool.gpt.web_search import GPTToolWebSearch
+from versionhq.tool.gpt.file_search import GPTToolFileSearch
+from versionhq.tool.gpt.cup import GPTToolCUP
 from versionhq._utils import process_config, Logger, UsageMetrics, ErrorType
 
 
-class TaskExecutionType(enum.Enum):
+class TaskExecutionType(IntEnum):
     """
     Enumeration to store task execution types of independent tasks without dependencies.
     """
@@ -174,14 +178,15 @@ class TaskOutput(BaseModel):
     """
     A class to store the final output of the given task in raw (string), json_dict, and pydantic class formats.
     """
-
-    task_id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True, description="store Task ID")
-    raw: str = Field(default="", description="Raw output of the task")
-    json_dict: Dict[str, Any] = Field(default=None, description="`raw` converted to dictionary")
+    task_id: UUID4 = Field(default_factory=uuid.uuid4)
+    raw: str = Field(default="")
+    json_dict: Dict[str, Any] = Field(default=None)
     pydantic: Optional[Any] = Field(default=None)
     tool_output: Optional[Any] = Field(default=None, description="stores tool result when the task takes tool output as its final output")
     callback_output: Optional[Any] = Field(default=None, description="stores task or agent callback outcome")
+    annotations: Optional[Dict[str, Any]] = Field(default=None)
     evaluation: Optional[InstanceOf[Evaluation]] = Field(default=None, description="stores overall evaluation of the task output. stored in ltm")
+    usage: Optional[UsageMetrics] = Field(default=None)
 
 
     def _fetch_value_of(self, key: str = None) -> Any:
@@ -311,7 +316,7 @@ class Task(BaseModel):
     response_schema: Optional[Type[BaseModel] | List[ResponseField]] = Field(default=None, description="stores response format")
 
     # tool usage
-    tools: Optional[List[ToolSet | Tool | Any]] = Field(default_factory=list, description="tools that the agent can use aside from their tools")
+    tools: Optional[List[Any]] = Field(default_factory=list, description="tools that the agent can use aside from their tools")
     can_use_agent_tools: bool = Field(default=True, description="whether the agent can use their own tools when executing the task")
     tool_res_as_final: bool = Field(default=False, description="when set True, tools res will be stored in the `TaskOutput`")
 
@@ -336,7 +341,6 @@ class Task(BaseModel):
     fsls: Optional[list[str]] = Field(default=None, description="stores ideal/weak responses")
 
     # recording
-    _usage: UsageMetrics = PrivateAttr(default=None)
     _delegations: int = 0
     processed_agents: Set[str] = Field(default_factory=set, description="store keys of the agents that executed the task")
     output: Optional[TaskOutput] = Field(default=None, description="store the final TaskOutput object")
@@ -361,24 +365,30 @@ class Task(BaseModel):
         for field in required_fields:
             if getattr(self, field) is None:
                 raise ValueError( f"{field} must be provided either directly or through config")
-
-        self._usage = UsageMetrics(id=self.id)
         return self
 
 
     @model_validator(mode="after")
     def set_up_tools(self) -> Self:
-        if not self.tools:
-            pass
-        else:
+        if self.tools:
             tool_list = []
             for item in self.tools:
-                if isinstance(item, Tool) or isinstance(item, ToolSet):
-                    tool_list.append(item)
-                elif (isinstance(item, dict) and "function" not in item) or isinstance(item, str):
-                    pass
-                else:
-                    tool_list.append(item) # address custom tool
+                match item:
+                    case Tool() | ToolSet() | BaseTool() | RagTool() | GPTToolCUP() | GPTToolFileSearch() | GPTToolWebSearch():
+                        tool_list.append(item)
+                    case type(item, callable):
+                        tool_list.append(Tool(func=item))
+                    case dict():
+                        tool = None
+                        try:
+                            tool = Tool(**item)
+                        except:
+                            try:
+                                tool = RagTool(**item)
+                            except:
+                                pass
+                    case _:
+                        pass
             self.tools = tool_list
         return self
 
@@ -472,7 +482,6 @@ class Task(BaseModel):
                 return output
         except:
             output = self._sanitize_raw_output(raw=raw)
-            self._usage.record_errors(type=ErrorType.FORMAT)
             return output
 
 
@@ -637,44 +646,47 @@ class Task(BaseModel):
 
         start_dt = datetime.datetime.now()
         task_output: InstanceOf[TaskOutput] = None
-        raw_output: str = None
-        tool_output: str | list = None
-        task_tools: List[List[InstanceOf[Tool]| InstanceOf[ToolSet] | Type[Tool]]] = []
         user_prompt, dev_prompt = None, None
 
-        if self.tools:
-            for item in self.tools:
-                if isinstance(item, ToolSet) or isinstance(item, Tool) or type(item) == Tool:
-                    task_tools.append(item)
-
         if self.allow_delegation == True:
             agent_to_delegate = self._select_agent_to_delegate(agent=agent)
             agent = agent_to_delegate
             self._delegations += 1
 
-        if self.tool_res_as_final == True:
-            user_prompt, dev_prompt, tool_output = agent.execute_task(task=self, context=context, task_tools=task_tools)
-            raw_output = str(tool_output) if tool_output else ""
-            if not raw_output:
-                self._usage.record_errors(type=ErrorType.TOOL)
-            task_output = TaskOutput(task_id=self.id, tool_output=tool_output, raw=raw_output)
+        user_prompt, dev_prompt, raw_output, usage = agent.execute_task(task=self, context=context)
+        match raw_output:
+            case TaskOutput():
+                raw_output.task_id = self.id
+                raw_output.usage = usage
+                task_output = raw_output
+
+            case str():
+                json_dict_output = self._create_json_output(raw=raw_output)
+                if "outcome" in json_dict_output:
+                    json_dict_output = self._create_json_output(raw=str(json_dict_output["outcome"]))
+
+                pydantic_output = self._create_pydantic_output(raw=raw_output, json_dict=json_dict_output)
+                task_output = TaskOutput(
+                    task_id=self.id,
+                    raw=raw_output if raw_output is not None else "",
+                    pydantic=pydantic_output,
+                    json_dict=json_dict_output,
+                    tool_output=raw_output if self.tool_res_as_final else None,
+                    usage=usage
+                )
 
-        else:
-            user_prompt, dev_prompt, raw_output = agent.execute_task(task=self, context=context, task_tools=task_tools)
-            json_dict_output = self._create_json_output(raw=raw_output)
-            if "outcome" in json_dict_output:
-                json_dict_output = self._create_json_output(raw=str(json_dict_output["outcome"]))
-
-            pydantic_output = self._create_pydantic_output(raw=raw_output, json_dict=json_dict_output)
-
-            task_output = TaskOutput(
-                task_id=self.id,
-                raw=raw_output if raw_output is not None else "",
-                pydantic=pydantic_output,
-                json_dict=json_dict_output,
-            )
+            case None | "":
+                task_output = TaskOutput(task_id=self.id, raw="", usage=usage)
+                task_output.usage.record_errors(type=ErrorType.FORMAT)
+
+            case _:
+                task_output = TaskOutput(
+                    task_id=self.id,
+                    raw=raw_output,
+                    tool_output=raw_output if self.tool_res_as_final else None,
+                    usage=usage
+                )
 
-        self.output = task_output
         self.processed_agents.add(agent.key)
 
         # if self.output_file: ## disabled for now
@@ -690,10 +702,9 @@ class Task(BaseModel):
             self._pfg.user_prompts.update({ index: user_prompt })
             self._pfg.dev_prompts.update({ index: dev_prompt })
 
-        if raw_output:
+        if task_output.raw:
             if self.should_evaluate:
                 task_output.evaluate(task=self)
-                self.output = task_output
 
             self._create_short_and_long_term_memories(agent=agent, task_output=task_output)
 
@@ -704,11 +715,14 @@ class Task(BaseModel):
                 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
-                self.output = task_output
-            self._store_logs()
 
         end_dt = datetime.datetime.now()
-        self._usage.record_latency(start_dt=start_dt, end_dt=end_dt)
+        task_output.usage.record_latency(start_dt=start_dt, end_dt=end_dt)
+        if task_output.json_dict and "output" in task_output.json_dict:
+            task_output.usage.record_errors(type=ErrorType.FORMAT)
+
+        self.output = task_output
+        self._store_logs()
         return task_output
 
 
@@ -719,7 +733,6 @@ class Task(BaseModel):
         from versionhq._prompt.model import Prompt
         from versionhq._prompt.auto_feedback import PromptFeedbackGraph
 
-        # self._usage = None
         prompt = Prompt(task=self, agent=agent, context=context)
         pfg = PromptFeedbackGraph(prompt=prompt, should_reform=self.human, reform_trigger_event=ReformTriggerEvent.USER_INPUT if self.human else None)
         pfg = pfg.set_up_graph()
@@ -728,11 +741,11 @@ class Task(BaseModel):
         try:
             if self._pfg and self.output is None:
                 res, all_outputs = self._pfg.activate()
-                if all_outputs: self._usage = self._pfg._usage
+                if all_outputs:
+                    res.usage = self._pfg.usage
                 return res
-
         except:
-            self._usage.record_errors(type=ErrorType.API)
+            self._pfg.usage.record_errors(type=ErrorType.API)
             Logger().log(level="error", message="Failed to execute the task.", color="red")
             return None
 

versionhq/task_graph/model.py

@@ -1,15 +1,16 @@
 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
 
@@ -18,13 +19,13 @@ 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.
     """
@@ -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_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
 
@@ -670,8 +673,9 @@ class TaskGraph(Graph):
 
             self.concl = res
             self.concl_response_schema = self.concl_response_schema if self.concl_response_schema 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()
+
+            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"
+#     }
+# ]