cua-agent 0.4.7__py3-none-any.whl → 0.4.9__py3-none-any.whl

agent/responses.py

@@ -40,7 +40,7 @@ def make_input_image_item(image_data: Union[str, bytes]) -> EasyInputMessagePara
             ResponseInputImageParam(
                 type="input_image",
                 image_url=f"data:image/png;base64,{base64.b64encode(image_data).decode('utf-8') if isinstance(image_data, bytes) else image_data}"
-            )
+            ) # type: ignore
         ],
         role="user",
         type="message"
@@ -205,3 +205,479 @@ def make_wait_item(call_id: Optional[str] = None) -> ResponseComputerToolCallPar
         status="completed",
         type="computer_call"
     )
+
+
+# Conversion functions between element descriptions and coordinates
+def convert_computer_calls_desc2xy(responses_items: List[Dict[str, Any]], desc2xy: Dict[str, tuple]) -> List[Dict[str, Any]]:
+    """
+    Convert computer calls from element descriptions to x,y coordinates.
+    
+    Args:
+        responses_items: List of response items containing computer calls with element_description
+        desc2xy: Dictionary mapping element descriptions to (x, y) coordinate tuples
+        
+    Returns:
+        List of response items with element_description replaced by x,y coordinates
+    """
+    converted_items = []
+    
+    for item in responses_items:
+        if item.get("type") == "computer_call" and "action" in item:
+            action = item["action"].copy()
+            
+            # Handle single element_description
+            if "element_description" in action:
+                desc = action["element_description"]
+                if desc in desc2xy:
+                    x, y = desc2xy[desc]
+                    action["x"] = x
+                    action["y"] = y
+                    del action["element_description"]
+            
+            # Handle start_element_description and end_element_description for drag operations
+            elif "start_element_description" in action and "end_element_description" in action:
+                start_desc = action["start_element_description"]
+                end_desc = action["end_element_description"]
+                
+                if start_desc in desc2xy and end_desc in desc2xy:
+                    start_x, start_y = desc2xy[start_desc]
+                    end_x, end_y = desc2xy[end_desc]
+                    action["path"] = [{"x": start_x, "y": start_y}, {"x": end_x, "y": end_y}]
+                    del action["start_element_description"]
+                    del action["end_element_description"]
+            
+            converted_item = item.copy()
+            converted_item["action"] = action
+            converted_items.append(converted_item)
+        else:
+            converted_items.append(item)
+    
+    return converted_items
+
+
+def convert_computer_calls_xy2desc(responses_items: List[Dict[str, Any]], desc2xy: Dict[str, tuple]) -> List[Dict[str, Any]]:
+    """
+    Convert computer calls from x,y coordinates to element descriptions.
+    
+    Args:
+        responses_items: List of response items containing computer calls with x,y coordinates
+        desc2xy: Dictionary mapping element descriptions to (x, y) coordinate tuples
+        
+    Returns:
+        List of response items with x,y coordinates replaced by element_description
+    """
+    # Create reverse mapping from coordinates to descriptions
+    xy2desc = {coords: desc for desc, coords in desc2xy.items()}
+    
+    converted_items = []
+    
+    for item in responses_items:
+        if item.get("type") == "computer_call" and "action" in item:
+            action = item["action"].copy()
+            
+            # Handle single x,y coordinates
+            if "x" in action and "y" in action:
+                coords = (action["x"], action["y"])
+                if coords in xy2desc:
+                    action["element_description"] = xy2desc[coords]
+                    del action["x"]
+                    del action["y"]
+            
+            # Handle path for drag operations
+            elif "path" in action and isinstance(action["path"], list) and len(action["path"]) == 2:
+                start_point = action["path"][0]
+                end_point = action["path"][1]
+                
+                if ("x" in start_point and "y" in start_point and 
+                    "x" in end_point and "y" in end_point):
+                    
+                    start_coords = (start_point["x"], start_point["y"])
+                    end_coords = (end_point["x"], end_point["y"])
+                    
+                    if start_coords in xy2desc and end_coords in xy2desc:
+                        action["start_element_description"] = xy2desc[start_coords]
+                        action["end_element_description"] = xy2desc[end_coords]
+                        del action["path"]
+            
+            converted_item = item.copy()
+            converted_item["action"] = action
+            converted_items.append(converted_item)
+        else:
+            converted_items.append(item)
+    
+    return converted_items
+
+
+def get_all_element_descriptions(responses_items: List[Dict[str, Any]]) -> List[str]:
+    """
+    Extract all element descriptions from computer calls in responses items.
+    
+    Args:
+        responses_items: List of response items containing computer calls
+        
+    Returns:
+        List of unique element descriptions found in computer calls
+    """
+    descriptions = set()
+    
+    for item in responses_items:
+        if item.get("type") == "computer_call" and "action" in item:
+            action = item["action"]
+            
+            # Handle single element_description
+            if "element_description" in action:
+                descriptions.add(action["element_description"])
+            
+            # Handle start_element_description and end_element_description for drag operations
+            if "start_element_description" in action:
+                descriptions.add(action["start_element_description"])
+            
+            if "end_element_description" in action:
+                descriptions.add(action["end_element_description"])
+    
+    return list(descriptions)
+
+
+# Conversion functions between responses_items and completion messages formats
+def convert_responses_items_to_completion_messages(messages: List[Dict[str, Any]], allow_images_in_tool_results: bool = True) -> List[Dict[str, Any]]:
+    """Convert responses_items message format to liteLLM completion format.
+    
+    Args:
+        messages: List of responses_items format messages
+        allow_images_in_tool_results: If True, include images in tool role messages.
+                                    If False, send tool message + separate user message with image.
+    """
+    completion_messages = []
+    
+    for message in messages:
+        msg_type = message.get("type")
+        role = message.get("role")
+        
+        # Handle user messages (both with and without explicit type)
+        if role == "user" or msg_type == "user":
+            content = message.get("content", "")
+            if isinstance(content, list):
+                # Handle list content (images, text blocks)
+                completion_content = []
+                for item in content:
+                    if item.get("type") == "input_image":
+                        completion_content.append({
+                            "type": "image_url",
+                            "image_url": {
+                                "url": item.get("image_url")
+                            }
+                        })
+                    elif item.get("type") == "input_text":
+                        completion_content.append({
+                            "type": "text",
+                            "text": item.get("text")
+                        })
+                    elif item.get("type") == "text":
+                        completion_content.append({
+                            "type": "text",
+                            "text": item.get("text")
+                        })
+                
+                completion_messages.append({
+                    "role": "user",
+                    "content": completion_content
+                })
+            elif isinstance(content, str):
+                # Handle string content
+                completion_messages.append({
+                    "role": "user",
+                    "content": content
+                })
+        
+        # Handle assistant messages
+        elif role == "assistant" or msg_type == "message":
+            content = message.get("content", [])
+            if isinstance(content, list):
+                text_parts = []
+                for item in content:
+                    if item.get("type") == "output_text":
+                        text_parts.append(item.get("text", ""))
+                    elif item.get("type") == "text":
+                        text_parts.append(item.get("text", ""))
+                
+                if text_parts:
+                    completion_messages.append({
+                        "role": "assistant",
+                        "content": "\n".join(text_parts)
+                    })
+        
+        # Handle reasoning items (convert to assistant message)
+        elif msg_type == "reasoning":
+            summary = message.get("summary", [])
+            text_parts = []
+            for item in summary:
+                if item.get("type") == "summary_text":
+                    text_parts.append(item.get("text", ""))
+            
+            if text_parts:
+                completion_messages.append({
+                    "role": "assistant",
+                    "content": "\n".join(text_parts)
+                })
+        
+        # Handle function calls
+        elif msg_type == "function_call":
+            # Add tool call to last assistant message or create new one
+            if not completion_messages or completion_messages[-1]["role"] != "assistant":
+                completion_messages.append({
+                    "role": "assistant",
+                    "content": "",
+                    "tool_calls": []
+                })
+            
+            if "tool_calls" not in completion_messages[-1]:
+                completion_messages[-1]["tool_calls"] = []
+            
+            completion_messages[-1]["tool_calls"].append({
+                "id": message.get("call_id"),
+                "type": "function",
+                "function": {
+                    "name": message.get("name"),
+                    "arguments": message.get("arguments")
+                }
+            })
+        
+        # Handle computer calls
+        elif msg_type == "computer_call":
+            # Add tool call to last assistant message or create new one
+            if not completion_messages or completion_messages[-1]["role"] != "assistant":
+                completion_messages.append({
+                    "role": "assistant",
+                    "content": "",
+                    "tool_calls": []
+                })
+            
+            if "tool_calls" not in completion_messages[-1]:
+                completion_messages[-1]["tool_calls"] = []
+            
+            action = message.get("action", {})
+            completion_messages[-1]["tool_calls"].append({
+                "id": message.get("call_id"),
+                "type": "function",
+                "function": {
+                    "name": "computer",
+                    "arguments": json.dumps(action)
+                }
+            })
+        
+        # Handle function/computer call outputs
+        elif msg_type in ["function_call_output", "computer_call_output"]:
+            output = message.get("output")
+            call_id = message.get("call_id")
+            
+            if isinstance(output, dict) and output.get("type") == "input_image":
+                if allow_images_in_tool_results:
+                    # Handle image output as tool response (may not work with all APIs)
+                    completion_messages.append({
+                        "role": "tool",
+                        "tool_call_id": call_id,
+                        "content": [{
+                            "type": "image_url",
+                            "image_url": {
+                                "url": output.get("image_url")
+                            }
+                        }]
+                    })
+                else:
+                    # Send tool message + separate user message with image (OpenAI compatible)
+                    completion_messages += [{
+                        "role": "tool",
+                        "tool_call_id": call_id,
+                        "content": "[Execution completed. See screenshot below]"
+                    }, {
+                        "role": "user",
+                        "content": [{
+                            "type": "image_url",
+                            "image_url": {
+                                "url": output.get("image_url")
+                            }
+                        }]
+                    }]
+            else:
+                # Handle text output as tool response
+                completion_messages.append({
+                    "role": "tool",
+                    "tool_call_id": call_id,
+                    "content": str(output)
+                })
+    
+    return completion_messages
+
+
+def convert_completion_messages_to_responses_items(completion_messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """Convert completion messages format to responses_items message format."""
+    responses_items = []
+    skip_next = False
+    
+    for i, message in enumerate(completion_messages):
+        if skip_next:
+            skip_next = False
+            continue
+
+        role = message.get("role")
+        content = message.get("content")
+        tool_calls = message.get("tool_calls", [])
+        
+        # Handle assistant messages with text content
+        if role == "assistant" and content and isinstance(content, str):
+            responses_items.append({
+                "type": "message",
+                "role": "assistant",
+                "content": [{
+                    "type": "output_text",
+                    "text": content
+                }]
+            })
+        
+        # Handle tool calls
+        if tool_calls:
+            for tool_call in tool_calls:
+                if tool_call.get("type") == "function":
+                    function = tool_call.get("function", {})
+                    function_name = function.get("name")
+                    
+                    if function_name == "computer":
+                        # Parse computer action
+                        try:
+                            action = json.loads(function.get("arguments", "{}"))
+                            # Change key from "action" -> "type"
+                            if action.get("action"):
+                                action["type"] = action["action"]
+                                del action["action"]
+                            responses_items.append({
+                                "type": "computer_call",
+                                "call_id": tool_call.get("id"),
+                                "action": action,
+                                "status": "completed"
+                            })
+                        except json.JSONDecodeError:
+                            # Fallback to function call format
+                            responses_items.append({
+                                "type": "function_call",
+                                "call_id": tool_call.get("id"),
+                                "name": function_name,
+                                "arguments": function.get("arguments", "{}"),
+                                "status": "completed"
+                            })
+                    else:
+                        # Regular function call
+                        responses_items.append({
+                            "type": "function_call",
+                            "call_id": tool_call.get("id"),
+                            "name": function_name,
+                            "arguments": function.get("arguments", "{}"),
+                            "status": "completed"
+                        })
+        
+        # Handle tool messages (function/computer call outputs)
+        elif role == "tool" and content:
+            tool_call_id = message.get("tool_call_id")
+            if isinstance(content, str):
+                # Check if this is the "[Execution completed. See screenshot below]" pattern
+                if content == "[Execution completed. See screenshot below]":
+                    # Look ahead for the next user message with image
+                    next_idx = i + 1
+                    if (next_idx < len(completion_messages) and 
+                        completion_messages[next_idx].get("role") == "user" and 
+                        isinstance(completion_messages[next_idx].get("content"), list)):
+                        # Found the pattern - extract image from next message
+                        next_content = completion_messages[next_idx]["content"]
+                        for item in next_content:
+                            if item.get("type") == "image_url":
+                                responses_items.append({
+                                    "type": "computer_call_output",
+                                    "call_id": tool_call_id,
+                                    "output": {
+                                        "type": "input_image",
+                                        "image_url": item.get("image_url", {}).get("url")
+                                    }
+                                })
+                                # Skip the next user message since we processed it
+                                skip_next = True
+                                break
+                    else:
+                        # No matching user message, treat as regular text
+                        responses_items.append({
+                            "type": "computer_call_output",
+                            "call_id": tool_call_id,
+                            "output": content
+                        })
+                else:
+                    # Determine if this is a computer call or function call output
+                    try:
+                        # Try to parse as structured output
+                        parsed_content = json.loads(content)
+                        if parsed_content.get("type") == "input_image":
+                            responses_items.append({
+                                "type": "computer_call_output",
+                                "call_id": tool_call_id,
+                                "output": parsed_content
+                            })
+                        else:
+                            responses_items.append({
+                                "type": "computer_call_output",
+                                "call_id": tool_call_id,
+                                "output": content
+                            })
+                    except json.JSONDecodeError:
+                        # Plain text output - could be function or computer call
+                        responses_items.append({
+                            "type": "function_call_output",
+                            "call_id": tool_call_id,
+                            "output": content
+                        })
+            elif isinstance(content, list):
+                # Handle structured content (e.g., images)
+                for item in content:
+                    if item.get("type") == "image_url":
+                        responses_items.append({
+                            "type": "computer_call_output",
+                            "call_id": tool_call_id,
+                            "output": {
+                                "type": "input_image",
+                                "image_url": item.get("image_url", {}).get("url")
+                            }
+                        })
+                    elif item.get("type") == "text":
+                        responses_items.append({
+                            "type": "function_call_output",
+                            "call_id": tool_call_id,
+                            "output": item.get("text")
+                        })
+        
+        # Handle actual user messages
+        elif role == "user" and content:
+            if isinstance(content, list):
+                # Handle structured user content (e.g., text + images)
+                user_content = []
+                for item in content:
+                    if item.get("type") == "image_url":
+                        user_content.append({
+                            "type": "input_image",
+                            "image_url": item.get("image_url", {}).get("url")
+                        })
+                    elif item.get("type") == "text":
+                        user_content.append({
+                            "type": "input_text",
+                            "text": item.get("text")
+                        })
+                
+                if user_content:
+                    responses_items.append({
+                        "role": "user",
+                        "type": "message",
+                        "content": user_content
+                    })
+            elif isinstance(content, str):
+                # Handle simple text user message
+                responses_items.append({
+                    "role": "user",
+                    "content": content
+                })
+    
+    return responses_items

agent/types.py

@@ -14,16 +14,18 @@ Tools = Optional[Iterable[ToolParam]]
 
 # Agent output types
 AgentResponse = ResponsesAPIResponse 
+AgentCapability = Literal["step", "click"]
 
-# Agent loop registration
-class AgentLoopInfo(BaseModel):
-    """Information about a registered agent loop"""
-    func: Callable
+
+# Agent config registration
+class AgentConfigInfo(BaseModel):
+    """Information about a registered agent config"""
+    agent_class: type
     models_regex: str
     priority: int = 0
     
     def matches_model(self, model: str) -> bool:
-        """Check if this loop matches the given model"""
+        """Check if this agent config matches the given model"""
         return bool(re.match(self.models_regex, model))
 
 # Computer tool interface

{cua_agent-0.4.7.dist-info → cua_agent-0.4.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cua-agent
-Version: 0.4.7
+Version: 0.4.9
 Summary: CUA (Computer Use) Agent for AI-driven computer interaction
 Author-Email: TryCua <gh@trycua.com>
 Requires-Python: >=3.11
@@ -15,7 +15,7 @@ Requires-Dist: python-dotenv>=1.0.1
 Requires-Dist: cua-computer<0.5.0,>=0.4.0
 Requires-Dist: cua-core<0.2.0,>=0.1.8
 Requires-Dist: certifi>=2024.2.2
-Requires-Dist: litellm>=1.74.8
+Requires-Dist: litellm>=1.74.12
 Provides-Extra: openai
 Provides-Extra: anthropic
 Provides-Extra: omni

cua_agent-0.4.9.dist-info/RECORD

@@ -0,0 +1,37 @@
+agent/__init__.py,sha256=vWbQYgjkzIso7zILSm4OAbNU_vrmN4HyYkfX8vC-Yi0,1547
+agent/__main__.py,sha256=lBUe8Niqa5XoCjwFfXyX7GtnUwjjZXC1-j4V9mvUYSc,538
+agent/adapters/__init__.py,sha256=szM2HMten2WkcqXeRnan__-sXjpyS4eyvIW0LXSfj4U,178
+agent/adapters/huggingfacelocal_adapter.py,sha256=CT3dwJnOWItB5eTqpn5i0Y1Ec6yRjaW7zhA14Ot9gz8,8066
+agent/agent.py,sha256=PP6UvNq_QYBYuEt97Dhono7g3hz1fQlMIapSQRhw59c,27761
+agent/callbacks/__init__.py,sha256=yxxBXUqpXQ-jRi_ixJMtmQPxoNRy5Vz1PUBzNNa1Dwg,538
+agent/callbacks/base.py,sha256=UnnnYlh6XCm6HKZZsAPaT_Eyo9LUYLyjyNwF-QRm6Ns,4691
+agent/callbacks/budget_manager.py,sha256=RyKM-7iXQcDotYvrw3eURzeEHEXvQjID-NobtvQWE7k,1832
+agent/callbacks/image_retention.py,sha256=tiuRT5ke9xXTb2eP8Gz-2ITyAMY29LURUH6AbjX3RP8,6165
+agent/callbacks/logging.py,sha256=OOxU97EzrxlnUAtiEnvy9FB7SwCUK90-rdpDFA2Ae4E,10921
+agent/callbacks/pii_anonymization.py,sha256=NEkUTUjQBi82nqus7kT-1E4RaeQ2hQrY7YCnKndLhP8,3272
+agent/callbacks/telemetry.py,sha256=PU7pkK7W1v1xjDN-9gA30lGvn4-WhqK3BPHGW3HpTOc,7497
+agent/callbacks/trajectory_saver.py,sha256=POE8aPT-MBzfW873wr6C7iiVUHtp483KwvLPxC1S3EY,11626
+agent/cli.py,sha256=LDKjahBcZLFjUSq3c4MYELJ3dxJ0n5lgY2WKTC3rXQY,12375
+agent/computer_handler.py,sha256=WBE78movl9ZHKWl-63GDoVSdYt71q4hUwQ6MvUfa140,4112
+agent/decorators.py,sha256=n8VvMsififWkmuk75Q7HIpo0xAA2yAeQ6J-OOiwbAKc,1836
+agent/loops/__init__.py,sha256=AQ8eLgAo9ZiSaRC8n9nMOudF2IWgIKd8130uWwQlIJg,297
+agent/loops/anthropic.py,sha256=joz7ibK6B4rTR3ue8a8rRcY0K0FIAv0TwcH2BL46Nmg,62557
+agent/loops/base.py,sha256=LK7kSTnc2CB88LI7qr2VP7LMq0eS5r2bSEnrxO6IN5U,2345
+agent/loops/composed_grounded.py,sha256=BgxufIyJCkWnJpp29PE1V2ce4iB9ictGjuVqFDx17B8,12122
+agent/loops/gta1.py,sha256=ha5TaUWqUzTffx_ow1WiBU8i3VNP-6FL5XC66ajPFjg,5829
+agent/loops/model_types.csv,sha256=GmFn4x80yoUpQZuQ-GXtJkPVlOLYWZ5u_5A73HRyeNE,112
+agent/loops/omniparser.py,sha256=-db8JUL2Orn47ERIaLbuNShAXn4LeIgYzRWphn_9Dg4,15071
+agent/loops/openai.py,sha256=8Ad_XufpENmLq1nEnhzF3oswPrPK1EPz-C5NU8UOEs0,8035
+agent/loops/uitars.py,sha256=EDq8AO20lrnwB013uJoWSkkz3TVRU9oG8DQ1VviXltc,31445
+agent/responses.py,sha256=ZI1nUYyyDNiiI7PwJpfta4RlGeuxpT-Tm-ptF6-ys9c,27498
+agent/telemetry.py,sha256=87ZTyBaT0wEPQn4v76II3g0V3GERuIVbypoX-Ug6FKQ,4786
+agent/types.py,sha256=zXev_CV9LvlYRkxzO_EmW1ZT70Z8qeGG3iHbzyYmV30,2425
+agent/ui/__init__.py,sha256=DTZpK85QXscXK2nM9HtpAhVBF13yAamUrtwrQSuV-kM,126
+agent/ui/__main__.py,sha256=vudWXYvGM0aNT5aZ94HPtGW8YXOZ4cLXepHyhUM_k1g,73
+agent/ui/gradio/__init__.py,sha256=yv4Mrfo-Sj2U5sVn_UJHAuwYCezo-5O4ItR2C9jzNko,145
+agent/ui/gradio/app.py,sha256=9UOPwuwspLrnHGY91zdzuRqkMH4cmwOBH-f-BC0gVC4,9077
+agent/ui/gradio/ui_components.py,sha256=hVMGZxAEq1LBHOqKj-RbDXJsj1j0Qw5dOV0ecWIHxmc,35397
+cua_agent-0.4.9.dist-info/METADATA,sha256=lTkzRc98XnFsPDzmDZ7WAwfU3BNM_sJljP5R8yAV5yw,12061
+cua_agent-0.4.9.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
+cua_agent-0.4.9.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+cua_agent-0.4.9.dist-info/RECORD,,

cua_agent-0.4.7.dist-info/RECORD

@@ -1,33 +0,0 @@
-agent/__init__.py,sha256=PfRgVa_aJQL9fK0D1g2r__Kdg3627EigNS31_M8Ivkk,1539
-agent/__main__.py,sha256=lBUe8Niqa5XoCjwFfXyX7GtnUwjjZXC1-j4V9mvUYSc,538
-agent/adapters/__init__.py,sha256=szM2HMten2WkcqXeRnan__-sXjpyS4eyvIW0LXSfj4U,178
-agent/adapters/huggingfacelocal_adapter.py,sha256=o2IQI1wuZWDYgGPj92dkxTb3uk07XjJdvC19O2_aeak,7963
-agent/agent.py,sha256=bSmc_5Jr4CTvTut8lgNwNpnk9w4sD9SACQb0GbT4zwg,24770
-agent/callbacks/__init__.py,sha256=yxxBXUqpXQ-jRi_ixJMtmQPxoNRy5Vz1PUBzNNa1Dwg,538
-agent/callbacks/base.py,sha256=UnnnYlh6XCm6HKZZsAPaT_Eyo9LUYLyjyNwF-QRm6Ns,4691
-agent/callbacks/budget_manager.py,sha256=RyKM-7iXQcDotYvrw3eURzeEHEXvQjID-NobtvQWE7k,1832
-agent/callbacks/image_retention.py,sha256=tiuRT5ke9xXTb2eP8Gz-2ITyAMY29LURUH6AbjX3RP8,6165
-agent/callbacks/logging.py,sha256=OOxU97EzrxlnUAtiEnvy9FB7SwCUK90-rdpDFA2Ae4E,10921
-agent/callbacks/pii_anonymization.py,sha256=NEkUTUjQBi82nqus7kT-1E4RaeQ2hQrY7YCnKndLhP8,3272
-agent/callbacks/telemetry.py,sha256=PU7pkK7W1v1xjDN-9gA30lGvn4-WhqK3BPHGW3HpTOc,7497
-agent/callbacks/trajectory_saver.py,sha256=POE8aPT-MBzfW873wr6C7iiVUHtp483KwvLPxC1S3EY,11626
-agent/cli.py,sha256=odI7cdl1psOGK-mEQzezsPzbRcLFwDbi7A2ukvYq8dk,12130
-agent/computer_handler.py,sha256=2gfFBeDk9Vd54x9mOqnswMo8BdjUduLo5I0RbBPLovY,3964
-agent/decorators.py,sha256=bCmcCjP31WEjWg1D91OE2jo7AZTfGa9cNgCnYUvjiyw,2832
-agent/loops/__init__.py,sha256=_qpP_--3ePdFkTZP8qmUEFlBsy6m4h8fj0gGLDKA7zw,217
-agent/loops/anthropic.py,sha256=MlEgQwuqHVQ5mMU9U36Gvd0YqR9_Jj1CFEczOgjSbFc,58200
-agent/loops/omniparser.py,sha256=m3bDNQ0Igc_HHVoAbjVNj599uRoC9Eap3DCALg6RZ54,11422
-agent/loops/openai.py,sha256=ArTqadeJY8F9N8ZLKfswlzgHV_54HbWJgLd4l6ele9w,3010
-agent/loops/uitars.py,sha256=L0NYxKoIiMfIHbyomnaiK3ZGLmLv3QMx9nX57GruAk0,26323
-agent/responses.py,sha256=ztSMEz8q4ykQAXF21UyQxkSZ6GeoDMydT5HZqKBPAXg,6660
-agent/telemetry.py,sha256=87ZTyBaT0wEPQn4v76II3g0V3GERuIVbypoX-Ug6FKQ,4786
-agent/types.py,sha256=GiLxIcF7s1XIh_WaY7tjdQPFpdTXb5MWVe_ZUPA0gkY,2364
-agent/ui/__init__.py,sha256=DTZpK85QXscXK2nM9HtpAhVBF13yAamUrtwrQSuV-kM,126
-agent/ui/__main__.py,sha256=vudWXYvGM0aNT5aZ94HPtGW8YXOZ4cLXepHyhUM_k1g,73
-agent/ui/gradio/__init__.py,sha256=yv4Mrfo-Sj2U5sVn_UJHAuwYCezo-5O4ItR2C9jzNko,145
-agent/ui/gradio/app.py,sha256=9UOPwuwspLrnHGY91zdzuRqkMH4cmwOBH-f-BC0gVC4,9077
-agent/ui/gradio/ui_components.py,sha256=hVMGZxAEq1LBHOqKj-RbDXJsj1j0Qw5dOV0ecWIHxmc,35397
-cua_agent-0.4.7.dist-info/METADATA,sha256=wCahxHMvzKL-FkTFy4XlZZirBwl1v-RYWRcYbFcJBDk,12060
-cua_agent-0.4.7.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
-cua_agent-0.4.7.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
-cua_agent-0.4.7.dist-info/RECORD,,