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

versionhq/__init__.py

@@ -25,7 +25,7 @@ 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.model import ComposioBaseTool
-from versionhq.tool.gpt.cup import GPTToolCUP, CUPToolSchema
+from versionhq.tool.gpt.cua import GPTToolCUA, CUAToolSchema
 from versionhq.tool.gpt.file_search import GPTToolFileSearch, FilterSchema
 from versionhq.tool.gpt.web_search import GPTToolWebSearch
 from versionhq.memory.contextual_memory import ContextualMemory
@@ -35,7 +35,7 @@ from versionhq.agent_network.formation import form_agent_network
 from versionhq.task_graph.draft import workflow
 
 
-__version__ = "1.2.4.7"
+__version__ = "1.2.4.8"
 __all__ = [
     "Agent",
 
@@ -90,8 +90,8 @@ __all__ = [
     "ToolHandler",
     "ComposioBaseTool",
 
-    "GPTToolCUP",
-    "CUPToolSchema",
+    "GPTToolCUA",
+    "CUAToolSchema",
     "GPTToolFileSearch",
     "FilterSchema",
     "GPTToolWebSearch",

versionhq/_utils/logger.py

@@ -51,7 +51,7 @@ class Logger(BaseModel):
     def log(self, level: str, message: str, color="yellow"):
         if self.verbose:
             timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-            self._printer.print(f"\n{timestamp} - versionHQ [{level.upper()}]: {message}", color=color)
+            self._printer.print(f"\n{timestamp} - vhq [{level.upper()}]: {message}", color=color)
 
         self._save(level=level, message=message, filename=self.filename)
 

versionhq/agent/model.py

@@ -126,7 +126,7 @@ class Agent(BaseModel):
         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.tool.gpt.cua import GPTToolCUA
 
         if not self.tools:
             return self
@@ -134,7 +134,7 @@ class Agent(BaseModel):
         tool_list = []
         for item in self.tools:
             match item:
-                case RagTool() | BaseTool() | GPTToolCUP() | GPTToolFileSearch() | GPTToolWebSearch():
+                case RagTool() | BaseTool() | GPTToolCUA() | GPTToolFileSearch() | GPTToolWebSearch():
                     tool_list.append(item)
 
                 case Tool():
@@ -433,7 +433,7 @@ class Agent(BaseModel):
         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.tool.gpt.cua import GPTToolCUA
 
         all_tools = []
         if task: all_tools = task.tools + self.tools if task.can_use_agent_tools else task.tools
@@ -446,7 +446,7 @@ class Agent(BaseModel):
                     case RagTool():
                         rag_tools.append(item)
 
-                    case GPTToolCUP() | GPTToolFileSearch() | GPTToolWebSearch():
+                    case GPTToolCUA() | GPTToolFileSearch() | GPTToolWebSearch():
                         gpt_tools.append(item)
 
                     case Tool() | BaseTool() | ToolSet():

versionhq/task/model.py

@@ -18,7 +18,7 @@ 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.tool.gpt.cua import GPTToolCUA
 from versionhq._utils import process_config, Logger, UsageMetrics, ErrorType
 
 
@@ -374,7 +374,7 @@ class Task(BaseModel):
             tool_list = []
             for item in self.tools:
                 match item:
-                    case Tool() | ToolSet() | BaseTool() | RagTool() | GPTToolCUP() | GPTToolFileSearch() | GPTToolWebSearch():
+                    case Tool() | ToolSet() | BaseTool() | RagTool() | GPTToolCUA() | GPTToolFileSearch() | GPTToolWebSearch():
                         tool_list.append(item)
                     case type(item, callable):
                         tool_list.append(Tool(func=item))
@@ -387,6 +387,8 @@ class Task(BaseModel):
                                 tool = RagTool(**item)
                             except:
                                 pass
+                        if tool:
+                            tool_list.append(tool)
                     case _:
                         pass
             self.tools = tool_list
@@ -713,7 +715,7 @@ class Task(BaseModel):
                 sig = inspect.signature(self.callback)
                 valid_keys = [param.name for param in sig.parameters.values() if param.kind == param.POSITIONAL_OR_KEYWORD]
                 valid_kwargs = { k: kwargs[k] if  k in kwargs else None for k in valid_keys }
-                callback_res = self.callback(**valid_kwargs)
+                callback_res = self.callback(**valid_kwargs, **task_output.json_dict )
                 task_output.callback_output = callback_res
 
         end_dt = datetime.datetime.now()

versionhq/tool/gpt/_enum.py

@@ -7,14 +7,14 @@ class GPTSizeEnum(str, Enum):
     HIGH = "high"
 
 
-class GPTCUPEnvironmentEnum(str, Enum):
+class GPTCUAEnvironmentEnum(str, Enum):
     BROWSER = "browser"
     MAC = "mac"
     WINDOWS = "windows"
     UNBUNTU = "ubuntu"
 
 
-class GPTCUPTypeEnum(str, Enum):
+class GPTCUATypeEnum(str, Enum):
     COMPUTER_CALL_OUTPUT = "computer_call_output"
     COMPUTER_USE_PREVIEW = "computer_use_preview"
 

versionhq/tool/gpt/cua.py

@@ -0,0 +1,295 @@
+import datetime
+import time
+from typing import List, Dict, Any, Tuple
+
+from versionhq._utils import convert_img_url
+from versionhq.tool.gpt import openai_client
+from versionhq.tool.gpt._enum import GPTCUAEnvironmentEnum, GPTCUATypeEnum, GPTSizeEnum
+from versionhq._utils import is_valid_enum, UsageMetrics, ErrorType, Logger, is_valid_url
+
+
+allowed_browsers = ['webkit', 'chromium', 'firefox']
+
+
+class CUAToolSchema:
+    type: str = GPTCUATypeEnum.COMPUTER_USE_PREVIEW.value
+    display_width: int = 1024
+    display_height: int = 768
+    environment: str = GPTCUAEnvironmentEnum.BROWSER.value
+
+    def __init__(
+            self,
+            type: str | GPTCUATypeEnum = None,
+            display_width: int = None,
+            display_height: int = None,
+            environment: str | GPTCUAEnvironmentEnum = 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=GPTCUATypeEnum, val=type):
+            self.type = type.value if isinstance(type, GPTCUATypeEnum) else type
+
+        if environment and is_valid_enum(enum=GPTCUAEnvironmentEnum, val=environment):
+            self.environment = environment.value if isinstance(environment, GPTCUAEnvironmentEnum) 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 GPTToolCUA:
+    model: str = "computer-use-preview"
+    tools: List[CUAToolSchema] = list()
+    user_prompt: str = None
+    img_url: str = None
+    web_url: str = "https://www.google.com"
+    browser: str = "firefox"
+    reasoning_effort: str = GPTSizeEnum.MEDIUM.value
+    truncation: str = "auto"
+
+    _response_ids: List[str] = list()
+    _call_ids: List[str] = list()
+    _usage: UsageMetrics = UsageMetrics()
+    _logger: Logger = Logger(info_file_save=True, filename="cua-task-{}".format(str(datetime.datetime.now().timestamp())) + ".png")
+
+
+    def __init__(
+        self,
+        user_prompt: str,
+        tools: List[CUAToolSchema] | CUAToolSchema = None,
+        img_url: str = None,
+        web_url: str = "https://www.google.com",
+        browser: str = "chromium",
+        reasoning_effort: GPTSizeEnum | str = None,
+        truncation: str = None,
+        _usage: UsageMetrics = UsageMetrics()
+    ):
+        self.user_prompt = user_prompt
+        self.web_url = web_url if is_valid_url(web_url) else "https://www.google.com"
+        self.browser = browser if browser in allowed_browsers else 'chromium'
+        self.truncation = truncation if truncation else self.truncation
+        self._usage = _usage
+        self._response_ids = list()
+        self._call_ids = list()
+
+        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 CUAToolSchema():
+                    if self.tools:
+                        self.tools.append(tools)
+                    else:
+                        self.tools = [tools]
+                case _:
+                    pass
+
+
+    def _take_screenshot(self, page: Any = None, path: str = None) -> Tuple[str | None, str | None]:
+        import base64
+        if not page:
+            return None, None
+
+        path = path if path else "screenshot.png"
+        screenshot_bytes = page.screenshot()
+        screenshot_base64 = base64.b64encode(screenshot_bytes).decode("utf-8")
+        self._logger.log(message=f"Action: screenshot", level="info", color="blue")
+        return screenshot_bytes, screenshot_base64
+
+
+    def _handle_model_action(self, page: Any, action: Any, action_type: str = None) -> bool:
+        """Creates a page object and performs actions."""
+
+        action_type = action_type if action_type else action.type
+        start_dt = datetime.datetime.now()
+
+        try:
+            match action_type:
+                case "click":
+                    x, y = action.x, action.y
+                    button = action.button
+                    self._logger.log(message=f"Action: click at ({x}, {y}) with button '{button}'", level="info", color="blue")
+                    if button != "left" and button != "right":
+                        button = "left"
+                    page.mouse.click(x, y, button=button)
+
+                case "scroll":
+                    x, y = action.x, action.y
+                    scroll_x, scroll_y = action.scroll_x, action.scroll_y
+                    self._logger.log(message=f"Action: scroll at ({x}, {y}) with offsets (scroll_x={scroll_x}, scroll_y={scroll_y})", level="info", color="blue")
+                    page.mouse.move(x, y)
+                    page.evaluate(f"window.scrollBy({scroll_x}, {scroll_y})")
+
+                case "keypress":
+                    keys = action.keys
+                    for k in keys:
+                        self._logger.log(message=f"Action: keypress '{k}'", level="info", color="blue")
+                        if k.lower() == "enter":
+                            page.keyboard.press("Enter")
+                        elif k.lower() == "space":
+                            page.keyboard.press(" ")
+                        else:
+                            page.keyboard.press(k)
+
+                case "type":
+                    text = action.text
+                    self._logger.log(message=f"Action: type text: {text}", level="info", color="blue")
+                    page.keyboard.type(text)
+
+                case "wait":
+                    self._logger.log(message=f"Action: wait", level="info", color="blue")
+                    time.sleep(2)
+
+                case "screenshot":
+                    pass
+
+                case _:
+                    self._logger.log(message=f"Unrecognized action: {action}", level="warning", color="yellow")
+
+        except Exception as e:
+            self._usage.record_errors(type=ErrorType.API)
+            self._logger.log(message=f"Error handling action {action}: {e}", level="error", color="red")
+
+        end_dt = datetime.datetime.now()
+        self._usage.record_latency(start_dt=start_dt, end_dt=end_dt)
+        return bool(self._usage.total_errors)
+
+
+    def run(self, screenshot: str = None) -> Tuple[Dict[str, Any], None, UsageMetrics]:
+        raw_res = dict()
+        usage = self._usage if self._usage else UsageMetrics()
+        start_dt = datetime.datetime.now()
+
+        try:
+            schema = self.schema
+            if screenshot and "output" in schema["input"][0]:
+                output_image_url = schema["input"][0]["output"]["image_url"].replace("SCREENSHOT", str(screenshot))
+                schema["input"][0]["output"]["image_url"] = output_image_url
+
+            res = openai_client.responses.create(**schema)
+            if not res:
+                usage.record_errors(ErrorType.TOOL)
+            else:
+                for item in res.output:
+                    match item.type:
+                        case "reasoning":
+                            raw_res.update(dict(reasoning=item.summary[0].text))
+                            if item.id and item.id.startwith('rs'):
+                                self._response_ids.append(item.id)
+                        case "computer_call":
+                            raw_res.update(dict(action=item.action))
+                            # self._response_ids.append(item.id)
+                            self._call_ids.append(item.call_id)
+                        case _:
+                            pass
+                usage.record_token_usage(**res.usage.__dict__)
+
+        except Exception as e:
+            self._logger.log(message=f"Failed to run: {str(e)}", color="red", level="error")
+            usage.record_errors(ErrorType.TOOL)
+
+        end_dt = datetime.datetime.now()
+        usage.record_latency(start_dt=start_dt, end_dt=end_dt)
+        return raw_res, None, usage
+
+
+    def invoke_playwright(self) -> Tuple[Dict[str, Any], None, UsageMetrics]:
+        """Handles computer use loop. Ref. OpenAI official website."""
+
+        from playwright.sync_api import sync_playwright
+
+        self._logger.log(message="Start the operation.", level="info", color="blue")
+
+        try:
+            with sync_playwright() as p:
+                b = p.firefox if self.browser == "firefox" else p.webkit if self.browser == "webkit" else p.chromium
+                browser = b.launch(headless=True)
+                page = browser.new_page()
+                if not browser or not page:
+                    return None, None, None
+
+                page.goto(self.web_url)
+                res, _, usage = self.run()
+                self._usage = usage
+                actions = [v for k, v in res.items() if k =="action"] if res else []
+                action = actions[0] if actions else None
+                start_dt = datetime.datetime.now()
+
+                if action:
+                    while True:
+                        self._handle_model_action(page=page, action=action)
+                        _, screenshot_base64 = self._take_screenshot(page=page)
+                        res, _, usage = self.run(screenshot=screenshot_base64)
+                        self._usage.agggregate(metrics=usage)
+                        if not res:
+                            usage.record_errors(type=ErrorType.API)
+                            break
+
+                        actions = [v for k, v in res.items() if k =="action"] if res else []
+                        action = actions[0] if actions else None
+                        if not action:
+                            break
+                else:
+                    self._usage.record_errors(type=ErrorType.TOOL)
+
+        except Exception as e:
+            self._logger.log(message=f"Failed to execute. {str(e)}", color="red", level="error")
+
+        end_dt = datetime.datetime.now()
+        self._usage.record_latency(start_dt=start_dt, end_dt=end_dt)
+        # browser.close()
+        return res, _, self._usage
+
+
+    @property
+    def schema(self) -> Dict[str, Any]:
+        """Formats args schema for CUA calling."""
+
+        tool_schema = [item.schema for item in self.tools]
+        schema = dict()
+        inputs = list()
+        previous_response_id = self._response_ids[-1] if self._response_ids and self._response_ids[-1].startswith("rs") else None
+
+        if self._call_ids:
+            inputs = [
+                {
+                    "call_id": self._call_ids[-1],
+                    "type": "computer_call_output",
+                    "output": { "type": "input_image", "image_url": f"data:image/png;base64,SCREENSHOT"}
+                }
+            ]
+            schema = dict(
+                model=self.model,
+                previous_response_id=previous_response_id,
+                tools=tool_schema,
+                input=inputs,
+                truncation=self.truncation
+            )
+
+        else:
+            img_url = convert_img_url(self.img_url) if self.img_url else None
+            input = [{ "role": "user", "content": self.user_prompt } ]
+            if img_url:
+                input.append({"type": "input_image", "image_url": f"data:image/png;base64,{img_url}"})
+            schema = dict(model=self.model, tools=tool_schema, input=input, reasoning={ "effort": self.reasoning_effort}, truncation=self.truncation)
+
+        return schema

versionhq/tool/gpt/file_search.py

@@ -1,3 +1,4 @@
+import datetime
 from typing import List, Dict, Any, Optional, Tuple
 
 from versionhq.tool.gpt import openai_client
@@ -87,6 +88,7 @@ class GPTToolFileSearch:
     max_num_results: int = 2
     include: List[str] = ["output[*].file_search_call.search_results"]
     filters: Optional[FilterSchema] = None
+    _usage: UsageMetrics = UsageMetrics()
 
     def __init__(
             self,
@@ -119,7 +121,8 @@ class GPTToolFileSearch:
     def run(self) -> Tuple[str, List[Dict[str, Any]], UsageMetrics] | None:
         raw_res = ""
         annotations = list()
-        usage = UsageMetrics()
+        usage = self._usage if self._usage else UsageMetrics()
+        start_dt = datetime.datetime.now()
 
         try:
             res = openai_client.responses.create(**self.schema)
@@ -130,10 +133,14 @@ class GPTToolFileSearch:
                 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
+
+        end_dt = datetime.datetime.now()
+        usage.record_latency(start_dt=start_dt, end_dt=end_dt)
+        self._usage = usage
+        return raw_res, annotations, usage
 
 
     @property

versionhq/tool/gpt/web_search.py

@@ -1,3 +1,4 @@
+import datetime
 from typing import Dict, Any, Optional, Tuple, List
 
 from versionhq.tool.gpt import openai_client
@@ -16,6 +17,7 @@ class GPTToolWebSearch:
     region: str = None # "London"
     search_content_size: str = GPTSizeEnum.MEDIUM.value
     _user_location: Optional[Dict[str, str]] = None
+    _usage: UsageMetrics = UsageMetrics()
 
 
     def __init__(
@@ -52,20 +54,25 @@ class GPTToolWebSearch:
 
         raw_res = ""
         annotations = list()
-        usage = UsageMetrics()
+        usage = self._usage if self._usage else UsageMetrics()
+        start_dt = datetime.datetime.now()
 
         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
+                content = res.output[0].content[0] if len(res.output) == 1 else res.output[1].content[0]
+                if content:
+                    raw_res = content.text
+                    annotations = [{ "title": item.title, "url": item.url } for item in content.annotations] if content.annotations else []
+                    usage.record_token_usage(**res.usage.__dict__)
         except:
             usage.record_errors(ErrorType.TOOL)
-            return raw_res, annotations, usage
+        end_dt = datetime.datetime.now()
+        usage.record_latency(start_dt=start_dt, end_dt=end_dt)
+        self._usage = usage
+        return raw_res, annotations, usage
 
 
     @property

{versionhq-1.2.4.7.dist-info → versionhq-1.2.4.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: versionhq
-Version: 1.2.4.7
+Version: 1.2.4.8
 Summary: Autonomous agent networks for task automation with multi-step reasoning.
 Author-email: Kuriko Iwai <kuriko@versi0n.io>
 License: MIT License
@@ -77,6 +77,7 @@ 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"
+Requires-Dist: pytest-playwright>=0.7.0; extra == "tools"
 Provides-Extra: torch
 Requires-Dist: torch>=2.6.0; extra == "torch"
 Requires-Dist: torchvision>=0.21.0; extra == "torch"
@@ -290,8 +291,11 @@ class CustomOutput(BaseModel):
    test1: str
    test2: list[str]
 
-def dummy_func(message: str, test1: str, test2: list[str]) -> str:
-   return f"""{message}: {test1}, {", ".join(test2)}"""
+def dummy_func(message: str, **kwargs) -> str:
+   test1 = kwargs["test1"] if kwargs and "test1" in kwargs else ""
+   test2 = kwargs["test2"] if kwargs and "test2" in kwargs else ""
+   if test1 and test2:
+      return f"""{message}: {test1}, {", ".join(test2)}"""
 
 task = vhq.Task(
    description="Amazing task",

{versionhq-1.2.4.7.dist-info → versionhq-1.2.4.8.dist-info}/RECORD

@@ -1,4 +1,4 @@
-versionhq/__init__.py,sha256=92oz-3IZ_FZAsIUPMZGHwCtcFDQ7dd1kJ79v_1Cz1PY,3333
+versionhq/__init__.py,sha256=oR5US-k9B6iSSPXIrHW2B0pFggJ2iav8hQ8vzR46gy4,3333
 versionhq/_prompt/auto_feedback.py,sha256=bbj37yTa11lRHpx-sV_Wmpb4dVnDBB7_v8ageUobHXY,3780
 versionhq/_prompt/constants.py,sha256=DOwUFnVVObEFqgnaMCDnW8fnw1oPMgS8JAqOiTuqleI,932
 versionhq/_prompt/model.py,sha256=wJlDM9yzrqlXWxyw4HkYQzPii2MPfqkgTF3qhXoJN2M,8038
@@ -8,13 +8,13 @@ versionhq/_utils/i18n.py,sha256=TwA_PnYfDLA6VqlUDPuybdV9lgi3Frh_ASsb_X8jJo8,1483
 versionhq/_utils/is_valid_enum.py,sha256=vGGIuvhDnFU2fUyyFxJyjw-NfByK0vfFAu1ShaHBeZE,720
 versionhq/_utils/is_valid_url.py,sha256=m8Mswvb-90FJtx1Heq6hPFDbwGgrv_R3wSbZQmEPM9Q,379
 versionhq/_utils/llm_as_a_judge.py,sha256=2XcuFqEVb6P6vHxWQNv8XM2b4APyvEir5QI9TPgHt_U,2353
-versionhq/_utils/logger.py,sha256=iHxGjm3BvUo5dHKLU88_pc0Z45wzSHOjyJGQkb7OADk,3255
+versionhq/_utils/logger.py,sha256=Y8id03u2ME7CDQl-HuS6M_LL8Q5SeMfoGPxp9mj9CGo,3249
 versionhq/_utils/process_config.py,sha256=YTGY_erW335RfceQfzS18YAqq-AAb-iSvKSjN7noD2E,782
 versionhq/_utils/usage_metrics.py,sha256=gDK6fZgT1njX4iPIPFapWxfxIiz-zZYv72p0u6M055U,3387
 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=D2WAiXCYsnQK3_Fe7CbbtvXsHWOaN6vde6m_QoW7fH4,2629
-versionhq/agent/model.py,sha256=kEsJri5RWSAzQ4jNYhS3WYSJTNyTT1huqyTlqjSK62E,26969
+versionhq/agent/model.py,sha256=HW_-k9wBhHpo1mtvDW6mGV2X20qQ7_ds4ZBubpTf_JU,26969
 versionhq/agent/parser.py,sha256=riG0dkdQCxH7uJ0AbdVdg7WvL0BXhUgJht0VtQvxJBc,4082
 versionhq/agent/rpm_controller.py,sha256=grezIxyBci_lDlwAlgWFRyR5KOocXeOhYkgN02dNFNE,2360
 versionhq/agent/TEMPLATES/Backstory.py,sha256=dkfuATUQ2g2WoUKkmgAIch-RB--bektGoQaUlsDOn0g,529
@@ -53,7 +53,7 @@ versionhq/storage/utils.py,sha256=r5ghA_ktdR2IuzlzKqZYCjsNxztEMzyhWLneA4cFuWY,74
 versionhq/task/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/task/evaluation.py,sha256=9jFOmjP-yy1vxRn781KmpdQ_d4J_ZA1UX_21Q3m-iuE,4122
 versionhq/task/formatter.py,sha256=N8Kmk9vtrMtBdgJ8J7RmlKNMdZWSmV8O1bDexmCWgU0,643
-versionhq/task/model.py,sha256=lTpog4ERVlcl95ku-ZCVbi7htT7hnI-YGM_JFZJ27k8,29462
+versionhq/task/model.py,sha256=-RZKeplcRSwfQzLj4lh2TyTkgxyPaiaujXKjsXDol54,29572
 versionhq/task/structured_response.py,sha256=tqOHpch8CVmMj0aZXjdDWtPNcVmBW8DVZnBvPBwS4PM,5053
 versionhq/task/TEMPLATES/Description.py,sha256=hKhpbz0ztbkUMXz9KiL-P40fis9OB5ICOdL9jCtgAhU,864
 versionhq/task_graph/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -70,12 +70,12 @@ versionhq/tool/composio/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG
 versionhq/tool/composio/model.py,sha256=GIFKso_e_4a3BdaulqU_i6Y9JFAExNBjzHUHR_zZeSI,8577
 versionhq/tool/composio/params.py,sha256=FvBuEXsOQUYnN7RTFxT20kAkiEYkxWKkiVtgpqOzKZQ,1843
 versionhq/tool/gpt/__init__.py,sha256=A6xCuf_GUBs7wfx904J_Vd2t1GJCcf0lMKOL7MbZce4,160
-versionhq/tool/gpt/_enum.py,sha256=fw31aYeQBY8vfRwzjvwa1IVhhpAAQt9m1jqQTjTBpLk,500
-versionhq/tool/gpt/cup.py,sha256=Vz7VmTQV0IvUZcyN9znH7d7XUvLzm2SlSXJ5NoJFk3Q,5048
-versionhq/tool/gpt/file_search.py,sha256=CoPwNNoGF4U-0OuUMixqjdt5YoO0tqWbdbR_7UE-dMk,5597
-versionhq/tool/gpt/web_search.py,sha256=NoeW7m_YxhUp8NanTjBt3GX6nAU6G8bi_jfpLfWyx90,3127
-versionhq-1.2.4.7.dist-info/LICENSE,sha256=cRoGGdM73IiDs6nDWKqPlgSv7aR4n-qBXYnJlCMHCeE,1082
-versionhq-1.2.4.7.dist-info/METADATA,sha256=7yovXpbFgfbIoPKXkVUUI5XvxkqJz6cxSJ6BGAkCFO4,21146
-versionhq-1.2.4.7.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-versionhq-1.2.4.7.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
-versionhq-1.2.4.7.dist-info/RECORD,,
+versionhq/tool/gpt/_enum.py,sha256=VaONDFZJNVe30Wf3Pl9s0XvxP_Xxqv3RNFcnqyigGFk,500
+versionhq/tool/gpt/cua.py,sha256=5yrgz_fc3IH_uB70J51wmRBWkfH53Qx-a29nmwWyOcs,12078
+versionhq/tool/gpt/file_search.py,sha256=r5JVlf-epKB8DDXyrzlkezguHUMir0JW-77LUHoy-w8,5813
+versionhq/tool/gpt/web_search.py,sha256=bpqEQopbq9KtqQ_0W7QAAJ5TyoKGiVM94-SMp5oqNFE,3483
+versionhq-1.2.4.8.dist-info/LICENSE,sha256=cRoGGdM73IiDs6nDWKqPlgSv7aR4n-qBXYnJlCMHCeE,1082
+versionhq-1.2.4.8.dist-info/METADATA,sha256=Gix43l0cnBFyfpXCDSg9R7Jm8FhrU2Te8jtdhg7sFck,21344
+versionhq-1.2.4.8.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
+versionhq-1.2.4.8.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
+versionhq-1.2.4.8.dist-info/RECORD,,

{versionhq-1.2.4.7.dist-info → versionhq-1.2.4.8.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (76.0.0)
+Generator: setuptools (76.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

versionhq/tool/gpt/cup.py

@@ -1,145 +0,0 @@
-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"
-#     }
-# ]