versionhq 1.2.4.13__py3-none-any.whl → 1.2.4.15__py3-none-any.whl

versionhq/__init__.py

@@ -10,7 +10,7 @@ load_dotenv(override=True)
 from versionhq.agent.model import Agent
 from versionhq.agent_network.model import AgentNetwork, Formation, Member, TaskHandlingProcess
 from versionhq.llm.model import LLM
-from versionhq.llm.llm_vars import LLM_CONTEXT_WINDOW_SIZES, MODEL_PARAMS, PROVIDERS, TEXT_MODELS
+from versionhq.llm.llm_vars import LLM_CONTEXT_WINDOW_SIZES, MODEL_PARAMS, PROVIDERS, MODELS
 from versionhq.clients.customer.model import Customer
 from versionhq.clients.product.model import Product, ProductProvider
 from versionhq.clients.workflow.model import MessagingWorkflow, MessagingComponent
@@ -35,7 +35,7 @@ from versionhq.agent_network.formation import form_agent_network
 from versionhq.task_graph.draft import workflow
 
 
-__version__ = "1.2.4.13"
+__version__ = "1.2.4.15"
 __all__ = [
     "Agent",
 
@@ -48,7 +48,7 @@ __all__ = [
     "LLM_CONTEXT_WINDOW_SIZES",
     "MODEL_PARAMS",
     "PROVIDERS",
-    "TEXT_MODELS",
+    "MODELS",
 
     "Customer",
     "Product",

versionhq/_prompt/model.py

@@ -14,7 +14,6 @@ class Prompt:
     agent: Any = None
     context: Any = None
 
-
     def __init__(self, task, agent, context):
         from versionhq.agent.model import Agent
         from versionhq.task.model import Task
@@ -32,22 +31,24 @@ class Prompt:
         output_prompt = ""
         output_formats_to_follow = dict()
 
-        if self.task.response_schema:
-            if isinstance(self.task.response_schema, list):
-                for item in self.task.response_schema:
-                    if isinstance(item, ResponseField):
-                        output_formats_to_follow[item.title] = f"<Return your answer in {item.data_type.__name__}>"
+        if self.task.is_multimodal == False:
+            if self.task.response_schema:
+                if isinstance(self.task.response_schema, list):
+                    for item in self.task.response_schema:
+                        if isinstance(item, ResponseField):
+                            output_formats_to_follow[item.title] = f"<Return your answer in {item.data_type.__name__}>"
 
-            elif issubclass(self.task.response_schema, BaseModel):
-                for k, v in self.task.response_schema.model_fields.items():
-                    output_formats_to_follow[k] = f"<Return your answer in {v.annotation}>"
+                elif issubclass(self.task.response_schema, BaseModel):
+                    for k, v in self.task.response_schema.model_fields.items():
+                        output_formats_to_follow[k] = f"<Return your answer in {v.annotation}>"
 
-            output_prompt = f"""Your response MUST be a valid JSON string that strictly follows the response format. Use double quotes for all keys and string values. Do not use single quotes, trailing commas, or any other non-standard JSON syntax.
-Ref. Output image: {output_formats_to_follow}
-    """
-        else:
-            output_prompt = "You MUST return your response as a valid JSON serializable string, enclosed in double quotes. Use double quotes for all keys and string values. Do NOT use single quotes, trailing commas, or other non-standard JSON syntax."
+                output_prompt = f"""Your response MUST be a valid JSON string that strictly follows the response format. Use double quotes for all keys and string values. Do not use single quotes, trailing commas, or any other non-standard JSON syntax.
+Ref. Output image: {output_formats_to_follow}"""
+            else:
+                output_prompt = "You MUST return your response as a valid JSON serializable string, enclosed in double quotes. Use double quotes for all keys and string values. Do NOT use single quotes, trailing commas, or other non-standard JSON syntax."
 
+        else:
+            output_prompt = "Return your response in concise manner."
         return dedent(output_prompt)
 
 
@@ -98,19 +99,20 @@ Ref. Output image: {output_formats_to_follow}
 
         content_messages = {}
 
-        if self.task.image:
-            img_url = convert_img_url(self.task.image)
-            if img_url:
-                content_messages.update({ "type": "image_url", "image_url": { "url": img_url }})
+        if self.task.is_multimodal == False:
+            if self.task.image:
+                img_url = convert_img_url(self.task.image)
+                if img_url:
+                    content_messages.update({ "type": "image_url", "image_url": { "url": img_url }})
 
-        if self.task.file:
-            if is_valid_url(self.task.file):
-                content_messages.update({ "type": "image_url", "image_url": self.file })
+            if self.task.file:
+                if is_valid_url(self.task.file):
+                    content_messages.update({ "type": "image_url", "image_url": self.file })
 
-        if self.task.audio and self.agent.llm.provider == "gemini":
-            audio_bytes = Path(self.task.audio).read_bytes()
-            encoded_data = base64.b64encode(audio_bytes).decode("utf-8")
-            content_messages.update({ "type": "image_url", "image_url": "data:audio/mp3;base64,{}".format(encoded_data)})
+            if self.task.audio and self.agent.llm.provider == "gemini":
+                audio_bytes = Path(self.task.audio).read_bytes()
+                encoded_data = base64.b64encode(audio_bytes).decode("utf-8")
+                content_messages.update({ "type": "image_url", "image_url": "data:audio/mp3;base64,{}".format(encoded_data)})
 
         return content_messages
 
@@ -188,7 +190,6 @@ Ref. Output image: {output_formats_to_follow}
         # else:
         #     user_prompt = self.agent._use_trained_data(user_prompt=user_prompt)
 
-
         content_prompt = self._format_content_prompt()
 
         messages = []

versionhq/_utils/__init__.py

@@ -5,3 +5,4 @@ from versionhq._utils.is_valid_url import is_valid_url
 from versionhq._utils.usage_metrics import UsageMetrics, ErrorType
 from versionhq._utils.convert_img_url import convert_img_url
 from versionhq._utils.is_valid_enum import is_valid_enum
+from versionhq._utils.handle_directory import handle_directory

versionhq/_utils/handle_directory.py

@@ -0,0 +1,15 @@
+import os
+import datetime
+from pathlib import Path
+
+
+def handle_directory(directory_name: str = None, filename: str = None, ext: str = 'png') -> Path:
+    """Creates and returns the absolute file path"""
+
+    os.makedirs(directory_name, exist_ok=True)
+
+    date = str(datetime.datetime.now().strftime('%j'))
+    cwd = Path.cwd()
+    DIRECTORY = cwd / f'{directory_name}/{filename}_{date}.{ext}'
+
+    return DIRECTORY

versionhq/agent/model.py

@@ -356,12 +356,9 @@ class Agent(BaseModel):
         response_format: Optional[Dict[str, Any]] = None,
         tools: Optional[List[InstanceOf[Tool]| InstanceOf[ToolSet] | Type[Tool]]] = None,
         tool_res_as_final: bool = False,
+        file: str = None, # absolute path to the content file (for multimodal use)
         ) -> Tuple[str, UsageMetrics]:
-        """
-        Create formatted prompts using the developer prompt and the agent's backstory, then call the base model.
-        - Execute the task up to `self.max_retry_limit` times in case of receiving an error or empty response.
-        - Pass the task_tools to the model to let them execute.
-        """
+        """Calls LLM."""
 
         task_execution_counter = 0
         iterations = 0
@@ -375,10 +372,10 @@ class Agent(BaseModel):
             Logger(**self._logger_config, filename=self.key).log(level="info", message=f"Messages sent to the model: {messages}", color="blue")
 
             if tool_res_as_final:
-                raw_response = self.func_calling_llm.call(messages=messages, tools=tools, tool_res_as_final=True)
+                raw_response = self.func_calling_llm.call(messages=messages, tools=tools, tool_res_as_final=True, file=file)
                 usage.record_token_usage(*self.func_calling_llm._usages)
             else:
-                raw_response = self.llm.call(messages=messages, response_format=response_format, tools=tools)
+                raw_response = self.llm.call(messages=messages, response_format=response_format, tools=tools, file=file)
                 usage.record_token_usage(*self.llm._usages)
 
             task_execution_counter += 1
@@ -454,14 +451,14 @@ class Agent(BaseModel):
         return rag_tools, gpt_tools, tools
 
 
-    def _handle_gpt_tools(self, gpt_tools: list[Any] = None) -> Any: # TaskOutput
+    def _handle_gpt_tools(self, gpt_tools: list[Any] = None) -> Any: # TaskOutput or None
         """Generates k, v pairs from multiple GPT tool results and stores them in TaskOutput class."""
 
         from versionhq.task.model import TaskOutput
         from versionhq._utils import UsageMetrics
 
         if not gpt_tools:
-            return
+            return None
 
         tool_res = dict()
         annotation_set = dict()
@@ -470,7 +467,9 @@ class Agent(BaseModel):
         for i, item in enumerate(gpt_tools):
             raw, annotations, usage = item.run()
             tool_res.update({ str(i): raw })
-            annotation_set.update({ str(i): annotations })
+
+            if annotations:
+                annotation_set.update({ str(i): annotations })
             total_usage.aggregate(metrics=usage)
 
         res = TaskOutput(raw=str(tool_res), tool_output=tool_res, usage=total_usage, annotations=annotation_set)
@@ -580,6 +579,7 @@ class Agent(BaseModel):
         raw_response = ""
         user_prompt, dev_prompt = "", ""
         usage = UsageMetrics(id=task.id)
+        file = task.audio if task.is_multimodal and task.audio else task.image if task.is_multimodal and task.image else task.file if task.is_multimodal and task.file else None
 
         if self.max_rpm and self._rpm_controller:
             self._rpm_controller._reset_request_count()
@@ -598,6 +598,7 @@ class Agent(BaseModel):
                 response_format=task._structure_response_format(model_provider=self.llm.provider),
                 tools=tools,
                 tool_res_as_final=task.tool_res_as_final,
+                file=file,
             )
 
         except Exception as e:

versionhq/llm/llm_vars.py

@@ -28,14 +28,13 @@ PROVIDERS = {
         "HF_ENDPOINT": "HF_ENDPOINT",
     },
     "azure":  {
-        "api_base": "AZURE_OPENAI_ENDPOINT",
+        "api_base": "AZURE_OPENAI_ENDPOINT_MODEL_NAME",
         "api_key": "AZURE_OPENAI_API_KEY",
         "api_version": "AZURE_OPENAI_API_VERSION",
     },
     "azure_ai": {
         "api_key": "AZURE_AI_API_KEY",
         "base_url": "AZURE_AI_API_BASE",
-
     }
 }
 
@@ -47,7 +46,7 @@ ENDPOINTS = [
 
 
 # Resaoning and text generation models
-TEXT_MODELS = {
+MODELS = {
     "openai": [
         "gpt-4.5-preview-2025-02-27",
         "gpt-4",
@@ -96,6 +95,10 @@ TEXT_MODELS = {
         "bedrock/cohere.command-light-text-v14",
     ],
     "azure": [
+        "azure/whisper",
+        "azure/whisper-2",
+        "azure/gpt-4o-mini-audio-preview",
+
         "azure/DeepSeek-V3",
         "azure/DeepSeek-R1",
         "azure/Llama-3.3-70B-Instruct",
@@ -163,6 +166,13 @@ TEXT_MODELS = {
 }
 
 
+AUDIO_TO_TEXT_MODELS = [
+    "azure/whisper",
+    "azure/whisper-2",
+    "azure/gpt-4o-mini-audio-preview",
+]
+
+
 """
 Max input token size by the model.
 """

versionhq/llm/model.py

@@ -12,9 +12,9 @@ import litellm
 from litellm import JSONSchemaValidationError, get_supported_openai_params, supports_response_schema
 from pydantic import BaseModel, Field, PrivateAttr, model_validator, ConfigDict
 
-from versionhq.llm.llm_vars import LLM_CONTEXT_WINDOW_SIZES, TEXT_MODELS, MODEL_PARAMS, PROVIDERS, ENDPOINTS
+from versionhq.llm.llm_vars import LLM_CONTEXT_WINDOW_SIZES, MODELS, AUDIO_TO_TEXT_MODELS, MODEL_PARAMS, PROVIDERS, ENDPOINTS
 from versionhq.tool.model import Tool, ToolSet
-from versionhq._utils import Logger
+from versionhq._utils import Logger, UsageMetrics, ErrorType
 
 
 load_dotenv(override=True)
@@ -115,7 +115,7 @@ class LLM(BaseModel):
                 self.provider = DEFAULT_MODEL_PROVIDER_NAME
 
             else:
-                provider_model_list = TEXT_MODELS.get(self.provider)
+                provider_model_list = MODELS.get(self.provider)
                 if provider_model_list:
                     self.model = provider_model_list[0]
                     self.provider = self.provider
@@ -127,29 +127,29 @@ class LLM(BaseModel):
         elif self.model and self.provider is None:
             model_match = [
                 item for item in [
-                    [val for val in v if val == self.model][0] for k, v in TEXT_MODELS.items() if [val for val in v if val == self.model]
+                    [val for val in v if val == self.model][0] for k, v in MODELS.items() if [val for val in v if val == self.model]
                 ] if item
             ]
             model_partial_match = [
                 item for item in [
-                    [val for val in v if val.find(self.model) != -1][0] for k, v in TEXT_MODELS.items() if [val for val in v if val.find(self.model) != -1]
+                    [val for val in v if val.find(self.model) != -1][0] for k, v in MODELS.items() if [val for val in v if val.find(self.model) != -1]
                 ] if item
             ]
-            provider_match = [k for k, v in TEXT_MODELS.items() if k == self.model]
+            provider_match = [k for k, v in MODELS.items() if k == self.model]
 
             if model_match:
                 self.model = model_match[0]
-                self.provider = [k for k, v in TEXT_MODELS.items() if self.model in v][0]
+                self.provider = [k for k, v in MODELS.items() if self.model in v][0]
 
             elif model_partial_match:
                 self.model = model_partial_match[0]
-                self.provider = [k for k, v in TEXT_MODELS.items() if [item for item in v if item.find(self.model) != -1]][0]
+                self.provider = [k for k, v in MODELS.items() if [item for item in v if item.find(self.model) != -1]][0]
 
             elif provider_match:
                 provider = provider_match[0]
-                if self.TEXT_MODELS.get(provider):
+                if self.MODELS.get(provider):
                     self.provider = provider
-                    self.model = self.TEXT_MODELS.get(provider)[0]
+                    self.model = self.MODELS.get(provider)[0]
                 else:
                     self.provider = DEFAULT_MODEL_PROVIDER_NAME
                     self.model = DEFAULT_MODEL_NAME
@@ -159,7 +159,7 @@ class LLM(BaseModel):
                 self.provider = DEFAULT_MODEL_PROVIDER_NAME
 
         else:
-            provider_model_list = TEXT_MODELS.get(self.provider)
+            provider_model_list = MODELS.get(self.provider)
             if self.model not in provider_model_list:
                 self._logger.log(level="warning", message=f"The provided model: {self._init_model_name} is not in the list. We will assign a default model.", color="yellow")
                 self.model = DEFAULT_MODEL_NAME
@@ -232,7 +232,16 @@ class LLM(BaseModel):
 
         valid_cred = {}
         for k, v in cred.items():
-            val = os.environ.get(v, None)
+            val = None
+            if '_MODEL_NAME' in v:
+                model_name = self.model.split('/')[-1] if self.model.split('/') else self.model
+                key = v.replace('_MODEL_NAME', f'_{model_name.replace("-", '_').replace(' ', '_').upper()}')
+                val = os.environ.get(key, None)
+                if not val:
+                    val = os.environ.get(v.replace('_MODEL_NAME', ''), None)
+            else:
+                val = os.environ.get(v, None)
+
             if val:
                 valid_cred[str(k)] = val
 
@@ -288,12 +297,12 @@ class LLM(BaseModel):
         messages: List[Dict[str, str]],
         response_format: Optional[Dict[str, Any]] = None,
         tools: Optional[List[Tool | ToolSet | Any ]] = None,
-        config: Optional[Dict[str, Any]] = {}, # any other conditions to pass on to the model.
-        tool_res_as_final: bool = False
+        config: Optional[Dict[str, Any]] = dict(),
+        tool_res_as_final: bool = False,
+        file: str = None
     ) -> str:
-        """
-        Execute LLM based on the agent's params and model params.
-        """
+        """Configures and calls the LLM (chat, text generation, reasoning models)."""
+
         litellm.drop_params = True
         litellm.set_verbose = True
 
@@ -302,9 +311,32 @@ class LLM(BaseModel):
                 self._set_callbacks(self.callbacks)
 
             try:
-                res, tool_res = None, ""
+                res = None
+                tool_res = ""
                 cred = self._set_credentials()
 
+                if file and self.model in AUDIO_TO_TEXT_MODELS:
+                    params = self._create_valid_params(config=config)
+                    audio_file = open(file, 'rb')
+                    res = litellm.transcription(
+                        model=self.model,
+                        file=audio_file,
+                        rompt=messages,
+                        ustom_llm_provider=self.endpoint_provider,
+                        response_format="json",
+                        **cred
+                    )
+                    usage = UsageMetrics()
+                    if res:
+                        usage.latency = res._response_ms if hasattr(res, '_response_ms') else 0
+                        self._usages.append(usage)
+                        return res.text
+                    else:
+                        usage.record_errors(type=ErrorType.API)
+                        self._usages.append(usage)
+                        return None
+
+
                 if self.provider == "gemini":
                     self.response_format = { "type": "json_object" } if not tools and self.model != "gemini/gemini-2.0-flash-thinking-exp" else None
                 elif response_format and "json_schema" in response_format:

versionhq/task/model.py

@@ -314,6 +314,7 @@ class Task(BaseModel):
     name: Optional[str] = Field(default=None)
     description: str = Field(description="Description of the actual task")
     response_schema: Optional[Type[BaseModel] | List[ResponseField]] = Field(default=None, description="stores response format")
+    is_multimodal: bool = False
 
     # tool usage
     tools: Optional[List[Any]] = Field(default_factory=list, description="tools that the agent can use aside from their tools")

versionhq/tool/gpt/_enum.py

@@ -7,7 +7,7 @@ class GPTSizeEnum(str, Enum):
     HIGH = "high"
 
 
-class GPTCUAEnvironmentEnum(str, Enum):
+class GPTCUABrowserEnum(str, Enum):
     BROWSER = "browser"
     MAC = "mac"
     WINDOWS = "windows"

versionhq/tool/gpt/cua.py

@@ -1,40 +1,33 @@
+import base64
 import datetime
 import time
-from typing import List, Dict, Any, Tuple
+import platform
+from typing import List, Dict, Any, Tuple, Literal, get_args
 
 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']
+from versionhq.tool.gpt._enum import GPTSizeEnum
+from versionhq._utils import is_valid_enum, UsageMetrics, ErrorType, Logger, is_valid_url, handle_directory
 
+BROWSER = Literal['chromium', 'firefox']
+TYPE = Literal["computer_call_output", "computer_use_preview"]
+ENV =  Literal["browser", "mac", "windows", "ubuntu"]
 
 class CUAToolSchema:
-    type: str = GPTCUATypeEnum.COMPUTER_USE_PREVIEW.value
+    type: TYPE = "computer_use_preview"
+    environment: ENV = "browser"
     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
-        ):
+    def __init__(self, type: str = None, display_width: int = None, display_height: int = None, environment: str = 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
+        if type and type in get_args(TYPE):
+            self.type = type
 
+        if environment and environment in get_args(ENV):
+            self.environment = environment
 
     @property
     def schema(self) -> Dict[str, Any]:
@@ -52,12 +45,14 @@ class GPTToolCUA:
     user_prompt: str = None
     img_url: str = None
     web_url: str = "https://www.google.com"
-    browser: str = "firefox"
+    browser: BROWSER = "firefox"
     reasoning_effort: str = GPTSizeEnum.MEDIUM.value
     truncation: str = "auto"
 
+    _schema: Dict[str, Any] = dict()
     _response_ids: List[str] = list()
     _call_ids: List[str] = list()
+    _calls: Dict[str, Dict[str, Any]] = dict() # stores response_id and raw output object.
     _usage: UsageMetrics = UsageMetrics()
     _logger: Logger = Logger(info_file_save=True, filename="cua-task-{}".format(str(datetime.datetime.now().timestamp())) + ".png")
 
@@ -74,8 +69,8 @@ class GPTToolCUA:
         _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.web_url = web_url if is_valid_url(web_url) else None
+        self.browser = browser if browser in get_args(BROWSER) else 'chromium'
         self.truncation = truncation if truncation else self.truncation
         self._usage = _usage
         self._response_ids = list()
@@ -104,104 +99,93 @@ class GPTToolCUA:
                     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."""
+    def _structure_schema(self, screenshot: str = None) -> None:
+        """Formats args schema for CUA calling."""
 
-        action_type = action_type if action_type else action.type
-        start_dt = datetime.datetime.now()
+        tool_schema = [item.schema for item in self.tools]
+        schema = dict()
+        inputs = list()
+        previous_response_id = self._response_ids[-1] if self._response_ids else None
+        # (self._response_ids[-1].startswith("rs") or  self._response_ids[-1].startswith("resp")) else None
 
-        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
+        if self._call_ids:
+            inputs = [
+                {
+                    "call_id": self._call_ids[-1],
+                    "type": "computer_call_output",
+                }
+            ]
+            if screenshot:
+                inputs[0].update({ "output": { "type": "computer_screenshot", "image_url": f"data:image/png;base64,{str(screenshot)}"}})
+
+            # if self._calls:
+            #     call = self._calls[self._call_ids[-1]]
+            #     if call and call.call_id not in inputs[0]:
+            #         inputs.append(call)
+
+            if previous_response_id:
+                schema = dict(
+                    model=self.model,
+                    previous_response_id=previous_response_id,
+                    tools=tool_schema,
+                    input=inputs,
+                    truncation=self.truncation
+                )
+            else:
+                schema = dict(
+                    model=self.model,
+                    tools=tool_schema,
+                    input=inputs,
+                    truncation=self.truncation
+                )
 
-                case _:
-                    self._logger.log(message=f"Unrecognized action: {action}", level="warning", color="yellow")
+        else:
+            input = [{ "role": "user", "content": self.user_prompt } ]
+            img_url = convert_img_url(self.img_url) if self.img_url else None
+            if img_url:
+                input.append({"type": "input_image", "image_url": f"data:image/png;base64,{img_url}"})
 
-        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")
+            schema = dict(
+                model=self.model,
+                tools=tool_schema,
+                input=input,
+                reasoning={ "effort": self.reasoning_effort},
+                truncation=self.truncation
+            )
 
-        end_dt = datetime.datetime.now()
-        self._usage.record_latency(start_dt=start_dt, end_dt=end_dt)
-        return bool(self._usage.total_errors)
+        self._schema = schema
+        # return self._schema
 
 
-    def run(self, screenshot: str = None) -> Tuple[Dict[str, Any], None, UsageMetrics]:
+    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)
+            self._structure_schema(screenshot=screenshot)
+            res = openai_client.responses.create(**self._schema)
             if not res:
                 usage.record_errors(ErrorType.TOOL)
             else:
+                self._response_ids.append(res.id)
                 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)
+                            reasoning = item.summary[0].text if item.summary and isinstance(item.summary, list) else str(item.summary) if item.summary else ""
+                            raw_res.update(dict(reasoning=reasoning))
+                            # 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)
+                            call_id = item.call_id
+                            self._call_ids.append(call_id)
+                            self._calls.update({ call_id: item })
                         case _:
                             pass
-                usage.record_token_usage(**res.usage.__dict__)
+            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")
@@ -212,84 +196,254 @@ class GPTToolCUA:
         return raw_res, None, usage
 
 
-    def invoke_playwright(self) -> Tuple[Dict[str, Any], None, UsageMetrics]:
+    def invoke_playwright(self) -> Dict[str, Any]:
         """Handles computer use loop. Ref. OpenAI official website."""
+        try:
+            from playwright.sync_api import sync_playwright
+        except Exception as e:
+            self._logger.log(level="error", message=f"Install Playwright by adding `versionhq[tools]` to requirements.txt or run `uv add playwright`. {str(e)}", color="red")
+            raise e
 
-        from playwright.sync_api import sync_playwright
-
-        self._logger.log(message="Start the operation.", level="info", color="blue")
+        import os
+        os.environ["DEBUG"] = "pw:browser"
+        self._logger.log(message="Start computer use.", level="info", color="blue")
+        start_dt = datetime.datetime.now()
+        res = None
+
+        # try:
+        p = sync_playwright().start()
+        b = p.firefox if self.browser == "firefox" else p.chromium
+        browser = b.launch(headless=True)
+        page = browser.new_page()
+        if not browser or not page:
+            return None, None, None
+
+        if self.web_url:
+            page.goto(self.web_url, timeout=3000000, wait_until="load", referer=None)
+            time.sleep(3)
+
+        res, _, usage = self._run()
+        self._usage.aggregate(metrics=usage)
+        actions = [v for k, v in res.items() if k =="action"] if res else []
+        action = actions[0] if actions else None
+
+        if action:
+            while True:
+                x = action.x if hasattr(action, 'x') else 0
+                y = action.y if hasattr(action, 'y') else 0
+                scroll_x = action.scroll_x if hasattr(action, 'scroll_x') else 0
+                scroll_y = action.scroll_y if hasattr(action, 'scroll_y') else 0
+                text = action.text if hasattr(action, 'text') else ''
+                screenshot_base64 = None
+                path = handle_directory(directory_name='_screenshots', filename=f'cua_playwright', ext='png')
+
+                match action.type:
+                    case "click":
+                        self._logger.log(message="Action: click", color="blue", level="info")
+                        button = action.button if hasattr(action, 'button') and (action.button == 'left' or action.button == 'right') else 'left'
+                        page.mouse.move(x, y)
+                        page.mouse.click(x, y, button=button)
+                        time.sleep(1)
+
+                    case "scroll":
+                        self._logger.log(message="Action: scroll", color="blue", level="info")
+                        page.mouse.move(x, y)
+                        page.evaluate(f"window.scrollBy({scroll_x}, {scroll_y})")
+                        time.sleep(1)
+
+                    case "move":
+                        self._logger.log(message="Action: move", color="blue", level="info")
+                        page.mouse.move(x, y)
+                        page.evaluate(f"window.scrollBy({scroll_x}, {scroll_y})")
+                        time.sleep(1)
+
+                    case "keypress":
+                        self._logger.log(message="Action: keypress", color="blue", level="info")
+                        keys = action.keys
+                        for k in keys:
+                            match k.lower():
+                                case "enter": page.keyboard.press("Enter")
+                                case "space": page.keyboard.press(" ")
+                                case _: page.keyboard.press(k)
+                        time.sleep(1)
+
+                    case "type":
+                        self._logger.log(message="Action: type", color="blue", level="info")
+                        page.keyboard.type(text)
+                        time.sleep(1)
+
+                    case "wait":
+                        self._logger.log(message="Action: wait", color="blue", level="info")
+                        time.sleep(3)
+
+                    case "screenshot":
+                        self._logger.log(message="Action: screenshot", color="blue", level="info")
+                        screenshot_bytes = page.screenshot(path=path)
+                        screenshot_base64 = base64.b64encode(screenshot_bytes).decode("utf-8")
+                        time.sleep(1)
+
+                    case _:
+                        self._logger.log(message=f"Unrecognized action: {action}", level="warning", color="yellow")
+                        return False
+
+                if not screenshot_base64:
+                    screenshot_bytes = page.screenshot(path=path)
+                    screenshot_base64 = base64.b64encode(screenshot_bytes).decode("utf-8")
+                    time.sleep(1)
+
+                res, _, usage = self._run(screenshot=screenshot_base64)
+                self._usage.aggregate(metrics=usage)
+                if not res:
+                    usage.record_errors(type=ErrorType.API)
+                    break
 
-        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)
+                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")
+        # except Exception as e:
+        #     self._logger.log(message=f"Failed to execute. {str(e)}", color="red", level="error")
+        #     browser.close()
 
         end_dt = datetime.datetime.now()
         self._usage.record_latency(start_dt=start_dt, end_dt=end_dt)
-        # browser.close()
-        return res, _, self._usage
+        return res
 
 
-    @property
-    def schema(self) -> Dict[str, Any]:
-        """Formats args schema for CUA calling."""
+    def invoke_selenium(self, **kwargs) -> Dict[str, Any]:
+        try:
+            from selenium import webdriver
+            from selenium.webdriver.common.keys import Keys
+            from selenium.webdriver.common.action_chains import ActionChains
+            from selenium.webdriver.common.actions.action_builder import ActionBuilder
+        except Exception as e:
+            self._logger.log(level="error", message=f"Install Selenium by `uv pip install versionhq[tools]` or `uv add selenium`. {str(e)}", color="red")
+            raise e
 
-        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
+        self._logger.log(message="Start computer use", level="info", color="blue")
 
-        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
-            )
+        start_dt = datetime.datetime.now()
 
+        driver = webdriver.Chrome(options=kwargs) if kwargs else webdriver.Chrome()
+        if self.tools:
+            driver.set_window_size(height=self.tools[0].display_height, width=self.tools[0].display_width)
+
+        if self.web_url:
+            driver.get(self.web_url)
+            time.sleep(3)
+
+        res, _, usage = self._run()
+        self._logger.log(message=f"Initial response: {res}", color="blue", level="info")
+        self._usage.aggregate(metrics=usage)
+        actions = [v for k, v in res.items() if k =="action"] if res else []
+        action = actions[0] if actions else None
+        action_chains = ActionChains(driver=driver)
+        action_builder = ActionBuilder(driver=driver)
+
+        if action:
+            while True:
+                x = action.x if hasattr(action, 'x') else 0
+                y = action.y if hasattr(action, 'y') else 0
+                scroll_x = action.scroll_x if hasattr(action, 'scroll_x') else 0
+                scroll_y = action.scroll_y if hasattr(action, 'scroll_y') else 0
+                text = action.text if hasattr(action, 'text') else ''
+                path = handle_directory(directory_name='_screenshots', filename=f'cua_selenium', ext='png')
+
+                match action.type:
+                    case 'click':
+                        self._logger.log(message="Action: click", color="blue", level="info")
+                        driver.execute_script(f'window.scrollBy({x}, {y})')
+                        action_chains.move_by_offset(xoffset=x, yoffset=y)
+                        action_chains.perform()
+
+                        if hasattr(action, 'button'):
+                            match action.button:
+                                case 'left':
+                                    action_chains.click()
+                                case 'right':
+                                    action_chains.context_click()
+                        action_chains.perform()
+                        time.sleep(1)
+
+                    case "scroll" | "move":
+                        self._logger.log(message="Action: scroll", color="blue", level="info")
+                        driver.execute_script(f'window.scrollBy({scroll_x}, {scroll_y})')
+                        time.sleep(1)
+
+                    case "keypress":
+                        self._logger.log(message="Action: keypress", color="blue", level="info")
+                        keys = action.keys
+                        if keys:
+                            for k in keys:
+                                match k.lower():
+                                    case "enter": action_chains.key_down(Keys.ENTER).perform()
+                                    case "space": action_chains.key_down(Keys.SPACE).perform()
+                                    case "select_all":
+                                        if platform.system() == 'Darwin':
+                                            action_chains.send_keys(Keys.COMMAND + "a").perform()
+                                        else:
+                                            action_chains.send_keys(Keys.CONTROL + "a").perform()
+                                    case _:
+                                        action_chains.key_down(Keys.SHIFT).send_keys(k).key_up(Keys.SHIFT).perform()
+                        time.sleep(1)
+
+                    case "type":
+                        self._logger.log(message="Action: type", color="blue", level="info")
+                        action_chains.send_keys(text).perform()
+                        time.sleep(1)
+
+                    case "wait":
+                        self._logger.log(message="Action: wait", color="blue", level="info")
+                        action_chains.pause(3)
+
+                    case "screenshot":
+                        self._logger.log(message="Action: screenshot", color="blue", level="info")
+                        driver.save_screenshot(path)
+                        time.sleep(1)
+
+                    case _:
+                        self._logger.log(message=f"Unrecognized action: {action}", level="warning", color="yellow")
+                        return False
+
+                with open(path, "rb") as image_file:
+                    res, usage = None, None
+                    if image_file:
+                        screenshot_base64 = base64.b64encode(image_file.read()).decode("utf-8")
+                        res, _, usage = self._run(screenshot=screenshot_base64)
+                    else:
+                        res, _, usage = self._run()
+
+                    self._usage.aggregate(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:
+                        self._logger.log(message="No action found.", color="yellow", level="warning")
+                        break
         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)
+            self._usage.record_errors(type=ErrorType.TOOL)
+
+        end_dt = datetime.datetime.now()
+        self._usage.record_latency(start_dt=start_dt, end_dt=end_dt)
+        return res
+
 
-        return schema
+    def run(self) -> Tuple[Dict[str, Any], None, UsageMetrics]:
+        """Core function to execute the tool."""
+
+        res = None
+        try:
+            res = self.invoke_playwright()
+        except:
+            self._call_ids = []
+            self._calls = dict()
+            self._response_ids = []
+            res = self.invoke_selenium()
+
+        return res, None, self._usage

{versionhq-1.2.4.13.dist-info → versionhq-1.2.4.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: versionhq
-Version: 1.2.4.13
+Version: 1.2.4.15
 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 @@ 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"
+Requires-Dist: selenium>=4.30.0; extra == "tools"
 Provides-Extra: torch
 Requires-Dist: torch>=2.6.0; extra == "torch"
 Requires-Dist: torchvision>=0.21.0; extra == "torch"

{versionhq-1.2.4.13.dist-info → versionhq-1.2.4.15.dist-info}/RECORD

@@ -1,9 +1,10 @@
-versionhq/__init__.py,sha256=YQ3V-FOICFD8-rGvToBJu4vTGaOywnolUk4SPec-66k,3356
+versionhq/__init__.py,sha256=oV5jD7iS1ttOqwTAukwrhJlWGH_j93WfbzvQP-jesA4,3346
 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
-versionhq/_utils/__init__.py,sha256=TOd3U_VCjvLzt0w-KV9cM1_ozEjzffhjyKX3F_JaqZg,418
+versionhq/_prompt/model.py,sha256=wi9ZhdNA-BzsWHEwrl0yP3ZNoqGJSLzZGyuJH04DJjQ,8293
+versionhq/_utils/__init__.py,sha256=S3GvJKOTHM43JzPdaDqT6Zkan9eQJpc4biqQBXiVq6o,481
 versionhq/_utils/convert_img_url.py,sha256=BlINw4RQ632m9P4FJbqzqYlzTLESBTRkhkstAopnNNY,408
+versionhq/_utils/handle_directory.py,sha256=n5y2ClC4A3f6rkv8XDfzoCqJcw-8sCJ0Q5q_ZiQ5uxw,417
 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
@@ -14,7 +15,7 @@ versionhq/_utils/usage_metrics.py,sha256=gDK6fZgT1njX4iPIPFapWxfxIiz-zZYv72p0u6M
 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=Cw9BdkDq45Ubzayq62A-nFqREBEIxMY0wfm_Xy8yP_w,26942
+versionhq/agent/model.py,sha256=9L7277HnY3rZL_-_aCStSskgivFNtqvQUq04ZBMbTac,27010
 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
@@ -38,8 +39,8 @@ versionhq/knowledge/source.py,sha256=-hEUPtJUHHMx4rUKtiHl19J8xAMw-WVBw34zwa2jZ08
 versionhq/knowledge/source_docling.py,sha256=XpavmLvh4dLcuTikj8MCE9KG52oQMafy7_wBneliMK0,4994
 versionhq/knowledge/storage.py,sha256=Kd-4r6aWM5EDaoXrzKXbgi1hY6tysSQARPGXM95qMmU,8266
 versionhq/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-versionhq/llm/llm_vars.py,sha256=aNvc5SNFfzQ2zOJffUJnKQI1JpmnvBf_jSYas8KNX-o,9030
-versionhq/llm/model.py,sha256=BEjWyFk0IWSUibHNc9apdFp3QdbGeBMQv4ZfvdgRjgE,17305
+versionhq/llm/llm_vars.py,sha256=msX_Sgv5Tycu_GGY9C8Mn1xNW-iDF-Jsq9SIjhgQKiA,9243
+versionhq/llm/model.py,sha256=1dDObVKJ3M-zK0oCxivG_aTXgcx_M05h1AbVtlGf57I,18697
 versionhq/memory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/memory/contextual_memory.py,sha256=QEMVvHuEXxY7M6-12S8HhyFKf108KfX8Zzt7paPW048,3882
 versionhq/memory/model.py,sha256=VQR1229t7GQPMItlGAHLtJrb6LrZfSoRA1DRW4z0SOU,8234
@@ -53,7 +54,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=-dqCQVRYF918RDM9mK_J7r4lMRwFqZ2G9NSePAU7DJY,29613
+versionhq/task/model.py,sha256=ApjV2JUe-gxRS8N0B6fBXzRFu-fQcna2gLlSKBhB_vM,29645
 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 +71,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=VaONDFZJNVe30Wf3Pl9s0XvxP_Xxqv3RNFcnqyigGFk,500
-versionhq/tool/gpt/cua.py,sha256=5yrgz_fc3IH_uB70J51wmRBWkfH53Qx-a29nmwWyOcs,12078
+versionhq/tool/gpt/_enum.py,sha256=iBtH964dyv6d326VXSJsthB7EKxFXLcZVQPfvaCtbdk,496
+versionhq/tool/gpt/cua.py,sha256=vdrPest2wWntMEKyvXcsR4WeivP5edE8B4rKqQbgHHY,19108
 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.13.dist-info/licenses/LICENSE,sha256=cRoGGdM73IiDs6nDWKqPlgSv7aR4n-qBXYnJlCMHCeE,1082
-versionhq-1.2.4.13.dist-info/METADATA,sha256=rvtqxOduTKrgS2alvluKuYC9NxUchTOGFcspTDs2VlM,21349
-versionhq-1.2.4.13.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
-versionhq-1.2.4.13.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
-versionhq-1.2.4.13.dist-info/RECORD,,
+versionhq-1.2.4.15.dist-info/licenses/LICENSE,sha256=cRoGGdM73IiDs6nDWKqPlgSv7aR4n-qBXYnJlCMHCeE,1082
+versionhq-1.2.4.15.dist-info/METADATA,sha256=0wsn8Zh2QnUwCo8LxL6Lmm9HuB9s67v_KYsVVkajqBQ,21399
+versionhq-1.2.4.15.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+versionhq-1.2.4.15.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
+versionhq-1.2.4.15.dist-info/RECORD,,

{versionhq-1.2.4.13.dist-info → versionhq-1.2.4.15.dist-info}/WHEEL

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