cua-agent 0.4.17__py3-none-any.whl → 0.4.18__py3-none-any.whl

agent/proxy/examples.py

@@ -0,0 +1,192 @@
+"""
+Example usage of the proxy server and client requests.
+"""
+import dotenv
+dotenv.load_dotenv()
+
+import asyncio
+import json
+import os
+import aiohttp
+from typing import Dict, Any
+
+
+async def test_http_endpoint():
+    """Test the HTTP /responses endpoint."""
+    
+    anthropic_api_key = os.getenv("ANTHROPIC_API_KEY")
+    assert isinstance(anthropic_api_key, str), "ANTHROPIC_API_KEY environment variable must be set"
+
+    # Example 1: Simple text request
+    simple_request = {
+        "model": "anthropic/claude-3-5-sonnet-20241022",
+        "input": "Tell me a three sentence bedtime story about a unicorn.",
+        "env": {
+            "ANTHROPIC_API_KEY": anthropic_api_key
+        }
+    }
+    
+    # Example 2: Multi-modal request with image
+    multimodal_request = {
+        "model": "anthropic/claude-3-5-sonnet-20241022",
+        "input": [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "input_text", "text": "what is in this image?"},
+                    {
+                        "type": "input_image",
+                        "image_url": "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg"
+                    }
+                ]
+            }
+        ],
+        "env": {
+            "ANTHROPIC_API_KEY": anthropic_api_key
+        }
+    }
+    
+    # Example 3: Request with custom agent and computer kwargs
+    custom_request = {
+        "model": "anthropic/claude-3-5-sonnet-20241022",
+        "input": "Take a screenshot and tell me what you see",
+        "env": {
+            "ANTHROPIC_API_KEY": anthropic_api_key
+        }
+    }
+    
+    # Test requests
+    base_url = "https://m-linux-96lcxd2c2k.containers.cloud.trycua.com:8443"
+    # base_url = "http://localhost:8000"
+    api_key = os.getenv("CUA_API_KEY")
+    assert isinstance(api_key, str), "CUA_API_KEY environment variable must be set"
+    
+    async with aiohttp.ClientSession() as session:
+        for i, request_data in enumerate([
+            simple_request,
+            # multimodal_request,
+            custom_request
+        ], 1):
+            print(f"\n--- Test {i} ---")
+            print(f"Request: {json.dumps(request_data, indent=2)}")
+            
+            try:
+                print(f"Sending request to {base_url}/responses")
+                async with session.post(
+                    f"{base_url}/responses",
+                    json=request_data,
+                    headers={"Content-Type": "application/json", "X-API-Key": api_key}
+                ) as response:
+                    result = await response.json()
+                    print(f"Status: {response.status}")
+                    print(f"Response: {json.dumps(result, indent=2)}")
+                    
+            except Exception as e:
+                print(f"Error: {e}")
+
+
+def curl_examples():
+    """Print curl command examples."""
+    
+    print("=== CURL Examples ===\n")
+    
+    print("1. Simple text request:")
+    print("""curl http://localhost:8000/responses \\
+  -H "Content-Type: application/json" \\
+  -d '{
+    "model": "anthropic/claude-3-5-sonnet-20241022",
+    "input": "Tell me a three sentence bedtime story about a unicorn."
+  }'""")
+    
+    print("\n2. Multi-modal request with image:")
+    print("""curl http://localhost:8000/responses \\
+  -H "Content-Type: application/json" \\
+  -d '{
+    "model": "anthropic/claude-3-5-sonnet-20241022",
+    "input": [
+      {
+        "role": "user",
+        "content": [
+          {"type": "input_text", "text": "what is in this image?"},
+          {
+            "type": "input_image",
+            "image_url": "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg"
+          }
+        ]
+      }
+    ]
+  }'""")
+    
+    print("\n3. Request with custom configuration:")
+    print("""curl http://localhost:8000/responses \\
+  -H "Content-Type: application/json" \\
+  -d '{
+    "model": "anthropic/claude-3-5-sonnet-20241022",
+    "input": "Take a screenshot and tell me what you see",
+    "agent_kwargs": {
+      "save_trajectory": true,
+      "verbosity": 20
+    },
+    "computer_kwargs": {
+      "os_type": "linux",
+      "provider_type": "cloud"
+    }
+  }'""")
+
+
+async def test_p2p_client():
+    """Example P2P client using peerjs-python."""
+    try:
+        from peerjs import Peer, PeerOptions, ConnectionEventType
+        from aiortc import RTCConfiguration, RTCIceServer
+        
+        # Set up client peer
+        options = PeerOptions(
+            host="0.peerjs.com",
+            port=443,
+            secure=True,
+            config=RTCConfiguration(
+                iceServers=[RTCIceServer(urls="stun:stun.l.google.com:19302")]
+            )
+        )
+        
+        client_peer = Peer(id="test-client", peer_options=options)
+        await client_peer.start()
+        
+        # Connect to proxy server
+        connection = client_peer.connect("computer-agent-proxy")
+        
+        @connection.on(ConnectionEventType.Open)
+        async def connection_open():
+            print("Connected to proxy server")
+            
+            # Send a test request
+            request = {
+                "model": "anthropic/claude-3-5-sonnet-20241022",
+                "input": "Hello from P2P client!"
+            }
+            await connection.send(json.dumps(request))
+        
+        @connection.on(ConnectionEventType.Data)
+        async def connection_data(data):
+            print(f"Received response: {data}")
+            await client_peer.destroy()
+        
+        # Wait for connection
+        await asyncio.sleep(10)
+        
+    except ImportError:
+        print("P2P dependencies not available. Install peerjs-python for P2P testing.")
+    except Exception as e:
+        print(f"P2P test error: {e}")
+
+
+if __name__ == "__main__":
+    import sys
+    
+    if len(sys.argv) > 1 and sys.argv[1] == "curl":
+        curl_examples()
+    elif len(sys.argv) > 1 and sys.argv[1] == "p2p":
+        asyncio.run(test_p2p_client())
+    else:
+        asyncio.run(test_http_endpoint())

agent/proxy/handlers.py

@@ -0,0 +1,248 @@
+"""
+Request handlers for the proxy endpoints.
+"""
+
+import asyncio
+import json
+import logging
+import os
+from contextlib import contextmanager
+from typing import Dict, Any, List, Union, Optional
+
+from ..agent import ComputerAgent
+from computer import Computer
+
+logger = logging.getLogger(__name__)
+
+
+class ResponsesHandler:
+    """Handler for /responses endpoint that processes agent requests."""
+    
+    def __init__(self):
+        self.computer = None
+        self.agent = None
+        # Simple in-memory caches
+        self._computer_cache: Dict[str, Any] = {}
+        self._agent_cache: Dict[str, Any] = {}
+    
+    async def setup_computer_agent(
+        self,
+        model: str,
+        agent_kwargs: Optional[Dict[str, Any]] = None,
+        computer_kwargs: Optional[Dict[str, Any]] = None,
+    ):
+        """Set up (and cache) computer and agent instances.
+
+        Caching keys:
+        - Computer cache key: computer_kwargs
+        - Agent cache key: {"model": model, **agent_kwargs}
+        """
+        agent_kwargs = agent_kwargs or {}
+        computer_kwargs = computer_kwargs or {}
+
+        def _stable_key(obj: Dict[str, Any]) -> str:
+            try:
+                return json.dumps(obj, sort_keys=True, separators=(",", ":"))
+            except Exception:
+                # Fallback: stringify non-serializable values
+                safe_obj = {}
+                for k, v in obj.items():
+                    try:
+                        json.dumps(v)
+                        safe_obj[k] = v
+                    except Exception:
+                        safe_obj[k] = str(v)
+                return json.dumps(safe_obj, sort_keys=True, separators=(",", ":"))
+
+        # Determine if custom tools are supplied; if so, skip computer setup entirely
+        has_custom_tools = bool(agent_kwargs.get("tools"))
+
+        computer = None
+        if not has_custom_tools:
+            # ---------- Computer setup (with cache) ----------
+            comp_key = _stable_key(computer_kwargs)
+
+            computer = self._computer_cache.get(comp_key)
+            if computer is None:
+                # Default computer configuration
+                default_c_config = {
+                    "os_type": "linux",
+                    "provider_type": "cloud",
+                    "name": os.getenv("CUA_CONTAINER_NAME"),
+                    "api_key": os.getenv("CUA_API_KEY"),
+                }
+                default_c_config.update(computer_kwargs)
+                computer = Computer(**default_c_config)
+                await computer.__aenter__()
+                self._computer_cache[comp_key] = computer
+                logger.info(f"Computer created and cached with key={comp_key} config={default_c_config}")
+            else:
+                logger.info(f"Reusing cached computer for key={comp_key}")
+
+        # Bind current computer reference (None if custom tools supplied)
+        self.computer = computer
+
+        # ---------- Agent setup (with cache) ----------
+        # Build agent cache key from {model} + agent_kwargs (excluding tools unless explicitly passed)
+        agent_kwargs_for_key = dict(agent_kwargs)
+        agent_key_payload = {"model": model, **agent_kwargs_for_key}
+        agent_key = _stable_key(agent_key_payload)
+
+        agent = self._agent_cache.get(agent_key)
+        if agent is None:
+            # Default agent configuration
+            default_a_config: Dict[str, Any] = {"model": model}
+            if not has_custom_tools:
+                default_a_config["tools"] = [computer]
+            # Apply user overrides, but keep tools unless user explicitly sets
+            if agent_kwargs:
+                if not has_custom_tools:
+                    agent_kwargs.setdefault("tools", [computer])
+                default_a_config.update(agent_kwargs)
+            # JSON-derived kwargs may have loose types; ignore static arg typing here
+            agent = ComputerAgent(**default_a_config)  # type: ignore[arg-type]
+            self._agent_cache[agent_key] = agent
+            logger.info(f"Agent created and cached with key={agent_key} model={model}")
+        else:
+            # Ensure cached agent uses the current computer tool (in case object differs)
+            # Only update if tools not explicitly provided in agent_kwargs
+            if not has_custom_tools:
+                try:
+                    agent.tools = [computer]
+                except Exception:
+                    pass
+            logger.info(f"Reusing cached agent for key={agent_key}")
+
+        # Bind current agent reference
+        self.agent = agent
+    
+    async def process_request(self, request_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Process a /responses request and return the result.
+        
+        Args:
+            request_data: Dictionary containing model, input, and optional kwargs
+            
+        Returns:
+            Dictionary with the agent's response
+        """
+        try:
+            # Extract request parameters
+            model = request_data.get("model")
+            input_data = request_data.get("input")
+            agent_kwargs = request_data.get("agent_kwargs", {})
+            computer_kwargs = request_data.get("computer_kwargs", {})
+            env_overrides = request_data.get("env", {}) or {}
+            
+            if not model:
+                raise ValueError("Model is required")
+            if not input_data:
+                raise ValueError("Input is required")
+            
+            # Apply env overrides for the duration of this request
+            with self._env_overrides(env_overrides):
+                # Set up (and possibly reuse) computer and agent via caches
+                await self.setup_computer_agent(model, agent_kwargs, computer_kwargs)
+
+                # Defensive: ensure agent is initialized for type checkers
+                agent = self.agent
+                if agent is None:
+                    raise RuntimeError("Agent failed to initialize")
+
+                # Convert input to messages format
+                messages = self._convert_input_to_messages(input_data)
+
+                # Run agent and get first result
+                async for result in agent.run(messages):
+                    # Return the first result and break
+                    return {
+                        "success": True,
+                        "result": result,
+                        "model": model
+                    }
+                
+            # If no results were yielded
+            return {
+                "success": False,
+                "error": "No results from agent",
+                "model": model
+            }
+            
+        except Exception as e:
+            logger.error(f"Error processing request: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "model": request_data.get("model", "unknown")
+            }
+    
+    def _convert_input_to_messages(self, input_data: Union[str, List[Dict[str, Any]]]) -> List[Dict[str, Any]]:
+        """Convert input data to messages format."""
+        if isinstance(input_data, str):
+            # Simple string input
+            return [{"role": "user", "content": input_data}]
+        elif isinstance(input_data, list):
+            # Already in messages format
+            messages = []
+            for msg in input_data:
+                # Convert content array format if needed
+                if isinstance(msg.get("content"), list):
+                    content_parts = []
+                    for part in msg["content"]:
+                        if part.get("type") == "input_text":
+                            content_parts.append({"type": "text", "text": part["text"]})
+                        elif part.get("type") == "input_image":
+                            content_parts.append({
+                                "type": "image_url",
+                                "image_url": {"url": part["image_url"]}
+                            })
+                        else:
+                            content_parts.append(part)
+                    messages.append({
+                        "role": msg["role"],
+                        "content": content_parts
+                    })
+                else:
+                    messages.append(msg)
+            return messages
+        else:
+            raise ValueError("Input must be string or list of messages")
+    
+    async def cleanup(self):
+        """Clean up resources."""
+        if self.computer:
+            try:
+                await self.computer.__aexit__(None, None, None)
+            except Exception as e:
+                logger.error(f"Error cleaning up computer: {e}")
+            finally:
+                self.computer = None
+        self.agent = None
+
+    @staticmethod
+    @contextmanager
+    def _env_overrides(env: Dict[str, str]):
+        """Temporarily apply environment variable overrides for the current process.
+        Restores previous values after the context exits.
+
+        Args:
+            env: Mapping of env var names to override for this request.
+        """
+        if not env:
+            # No-op context
+            yield
+            return
+
+        original: Dict[str, Optional[str]] = {}
+        try:
+            for k, v in env.items():
+                original[k] = os.environ.get(k)
+                os.environ[k] = str(v)
+            yield
+        finally:
+            for k, old in original.items():
+                if old is None:
+                    # Was not set before
+                    os.environ.pop(k, None)
+                else:
+                    os.environ[k] = old

{cua_agent-0.4.17.dist-info → cua_agent-0.4.18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cua-agent
-Version: 0.4.17
+Version: 0.4.18
 Summary: CUA (Computer Use) Agent for AI-driven computer interaction
 Author-Email: TryCua <gh@trycua.com>
 Requires-Python: >=3.12
@@ -38,7 +38,7 @@ Requires-Dist: python-dotenv>=1.0.1; extra == "ui"
 Provides-Extra: cli
 Requires-Dist: yaspin>=3.1.0; extra == "cli"
 Provides-Extra: hud
-Requires-Dist: hud-python==0.2.10; extra == "hud"
+Requires-Dist: hud-python<0.5.0,>=0.4.12; extra == "hud"
 Provides-Extra: all
 Requires-Dist: ultralytics>=8.0.0; extra == "all"
 Requires-Dist: cua-som<0.2.0,>=0.1.0; extra == "all"
@@ -49,7 +49,7 @@ Requires-Dist: transformers>=4.54.0; extra == "all"
 Requires-Dist: gradio>=5.23.3; extra == "all"
 Requires-Dist: python-dotenv>=1.0.1; extra == "all"
 Requires-Dist: yaspin>=3.1.0; extra == "all"
-Requires-Dist: hud-python==0.2.10; extra == "all"
+Requires-Dist: hud-python<0.5.0,>=0.4.12; extra == "all"
 Description-Content-Type: text/markdown
 
 <div align="center">

{cua_agent-0.4.17.dist-info → cua_agent-0.4.18.dist-info}/RECORD

@@ -1,17 +1,19 @@
 agent/__init__.py,sha256=MaW-BczJ-lCACPYH39DvFhE7ZWiSo7sBO6pBfyO7Nxc,1269
 agent/__main__.py,sha256=lBUe8Niqa5XoCjwFfXyX7GtnUwjjZXC1-j4V9mvUYSc,538
-agent/adapters/__init__.py,sha256=lNH6srgIMmZOI7dgicJs3LCk_1MeqLF0lou9n7b23Ts,238
+agent/adapters/__init__.py,sha256=Q_OxxwXBcBIetQ_DtHS5bwZWXrvCKPX2grCg8R0UKek,301
 agent/adapters/huggingfacelocal_adapter.py,sha256=Uqjtcohhzd33VFh38Ra2y4Uv_lTghMswoqS1t-KKFkw,8480
 agent/adapters/human_adapter.py,sha256=xT4nnfNXb1z-vnGFlLmFEZN7TMcoMBGS40MtR1Zwv4o,13079
-agent/agent.py,sha256=XBZu_iNSWzyBk7Qf9Q-FkyHoqdikdldK6T1LAM3lLWY,29102
-agent/callbacks/__init__.py,sha256=yxxBXUqpXQ-jRi_ixJMtmQPxoNRy5Vz1PUBzNNa1Dwg,538
+agent/adapters/mlxvlm_adapter.py,sha256=J-LsRsbMFEpgyC3V-Poqi9kr_dzEGfAn5vpaiwSsA_k,14855
+agent/agent.py,sha256=JjyEgj3jTnhVcZAX7ANZtePRMkbKD0kzkukSlgwaQNk,29365
+agent/callbacks/__init__.py,sha256=et6pNfX_AiJqhVzUfCvcjzFbDhfLoHazKCXN5sqwxaM,631
 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/operator_validator.py,sha256=dLvR749glMPiGt8UP-XMLm_LcaTUUhWvRZJN_qkHV7Y,6430
 agent/callbacks/pii_anonymization.py,sha256=NEkUTUjQBi82nqus7kT-1E4RaeQ2hQrY7YCnKndLhP8,3272
 agent/callbacks/telemetry.py,sha256=RbUDhE41mTi8g9hNre0EpltK_NUZkLj8buJLWBzs0Ek,7363
-agent/callbacks/trajectory_saver.py,sha256=VHbiDQzI_XludkWhZIVqIMrsxgwKfFWwVtqaRot_D4U,12231
+agent/callbacks/trajectory_saver.py,sha256=GZBU4EV_pkp3hSin08kwgC08QtNCvx0y8ZMFz3bulLs,12389
 agent/cli.py,sha256=AgaXwywHd3nGQWuqMRj6SbPyFaCPjfo5980Y1ApQOTQ,12413
 agent/computers/__init__.py,sha256=39ISJsaREaQIZckpzxSuLhuR763wUU3TxUux78EKjAg,1477
 agent/computers/base.py,sha256=hZntX4vgc1ahD3EnFeb9lUjtBmgka1vb27hndPl9tKQ,2187
@@ -22,20 +24,20 @@ agent/human_tool/__init__.py,sha256=3m5_g-Fo_0yX5vi7eg-A92oTqO0N3aY929Ajp78HKsE,
 agent/human_tool/__main__.py,sha256=VsW2BAghlonOuqZbP_xuCsaec9bemA1I_ibnDcED9D4,1068
 agent/human_tool/server.py,sha256=ceuL5kw_RjgAi8fueLU3nTjyzOLE25Shv1oTJnSHsoQ,7964
 agent/human_tool/ui.py,sha256=2Jk3Bh-Jctya8GUG-qtYbdi-1qDdwOtcAlUeiIqsoIE,26584
-agent/integrations/hud/__init__.py,sha256=1lqeM6vJAekr38l7yteLNa-Hn3R2eXCusT2FAaY8VPE,2943
-agent/integrations/hud/adapter.py,sha256=M7J71q29Ndr4xXIW7Y6H_HIlJmnp-JlKG_4zKZTuyps,4088
-agent/integrations/hud/agent.py,sha256=vXmI7OBez5lokQ9dCcgWeT8N68xfWpsWT3S36MLhdas,17264
-agent/integrations/hud/computer_handler.py,sha256=N5pVKeKW9bJ-oceYrE7IIHbx6ZrQRQnHItTGrytoHRM,6788
+agent/integrations/hud/__init__.py,sha256=0FWeAlVqe9TZX7U26Wu8O6Zsg9UIvNNN5A-8YB1Bb_k,8339
+agent/integrations/hud/proxy.py,sha256=yA7C2jeXnrpI5HS0VgCvn0BflVbAORZynIfyE27rvBg,7782
 agent/loops/__init__.py,sha256=Ef8aj07l3osibwDk-DTo80PrpL4_GdKRTP1ikl_b-BQ,328
-agent/loops/anthropic.py,sha256=lvDscOaOcESBWZvnjKntQRWJZ4cEaFJhSsmmFc7J1ow,69562
+agent/loops/anthropic.py,sha256=Th3dNv8FULvyDXx7aPVGSzbrqBiDNFXRso3DSa88d_w,70301
 agent/loops/base.py,sha256=LK7kSTnc2CB88LI7qr2VP7LMq0eS5r2bSEnrxO6IN5U,2345
-agent/loops/composed_grounded.py,sha256=BgxufIyJCkWnJpp29PE1V2ce4iB9ictGjuVqFDx17B8,12122
+agent/loops/composed_grounded.py,sha256=8oJoqaRzKWbI9I4VoFuAoUzQ11_CFnYT-EdPOy-NVEQ,12349
 agent/loops/glm45v.py,sha256=V1f-5vAifbYcY-qTc7fW2KXVRkAfApQI_EjavH3X2ak,35110
 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=PVNOdwcn2K6RgaxoU-9I4HjBTsEH073M11LTqTrN7C4,31849
+agent/loops/openai.py,sha256=3UEXdecqGkyknhTgp6zxr_cNCVg5vM-61I6SKMNl6m8,8692
+agent/loops/uitars.py,sha256=QyEWyrhkI5MCksTunntY-5jtETd4pwcQB-DyzmiWezo,32350
+agent/proxy/examples.py,sha256=GYFJ-sfDsSNZr9n_qpvDx_0rShqoKE5JW0ibbljWfoo,6192
+agent/proxy/handlers.py,sha256=48mMNyZOU3dJQ6oI5r2kDDe29rcU49MConlB0MZeCsU,9602
 agent/responses.py,sha256=_SoN4BkaTxMHMB21EOtDc_aDBIJlfDwsCzszMBnIkH0,30764
 agent/types.py,sha256=h6SnmTAEAaryVCjwVZFAuCbio9UW13OqgQEV7HKmZVM,1060
 agent/ui/__init__.py,sha256=DTZpK85QXscXK2nM9HtpAhVBF13yAamUrtwrQSuV-kM,126
@@ -43,7 +45,7 @@ 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=Ol97YEbwREZZQ9_PMjVHlfOcu9BGsawxgAGAm79hT80,9117
 agent/ui/gradio/ui_components.py,sha256=dJUvKDmc1oSejtoR_gU_oWWYwxaOOQyPloSYRGMrUCQ,36068
-cua_agent-0.4.17.dist-info/METADATA,sha256=ngs59u9_Ec6SfwAdvr8UytvNFLt9DV0pMIQAb3ElbA0,12698
-cua_agent-0.4.17.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
-cua_agent-0.4.17.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
-cua_agent-0.4.17.dist-info/RECORD,,
+cua_agent-0.4.18.dist-info/METADATA,sha256=SuqfpH4uM1eqOehMaWA_rMgOknsiU6kvt23DMD-7_5Q,12712
+cua_agent-0.4.18.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
+cua_agent-0.4.18.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+cua_agent-0.4.18.dist-info/RECORD,,

agent/integrations/hud/adapter.py

@@ -1,121 +0,0 @@
-"""HUD Adapter for ComputerAgent integration."""
-
-from __future__ import annotations
-
-from typing import Any, ClassVar
-
-from hud.adapters.common import CLA, Adapter
-from hud.adapters.common.types import (
-    CLAButton,
-    CLAKey,
-    ClickAction,
-    CustomAction,
-    DragAction,
-    MoveAction,
-    Point,
-    PressAction,
-    ResponseAction,
-    ScreenshotFetch,
-    ScrollAction,
-    TypeAction,
-    WaitAction,
-)
-
-
-class ComputerAgentAdapter(Adapter):
-    """Adapter for ComputerAgent to work with HUD."""
-    
-    KEY_MAP: ClassVar[dict[str, CLAKey]] = {
-        "return": "enter",
-        "arrowup": "up",
-        "arrowdown": "down",
-        "arrowleft": "left",
-        "arrowright": "right",
-        "cmd": "ctrl",
-        "super": "win",
-        "meta": "win",
-    }
-
-    BUTTON_MAP: ClassVar[dict[str, CLAButton]] = {
-        "wheel": "middle",
-        "middle": "middle",
-    }
-
-    def __init__(self) -> None:
-        super().__init__()
-        # ComputerAgent default dimensions (can be overridden)
-        self.agent_width = 1024
-        self.agent_height = 768
-
-    def _map_key(self, key: str) -> CLAKey:
-        """Map a key to its standardized form."""
-        return self.KEY_MAP.get(key.lower(), key.lower())  # type: ignore
-
-    def convert(self, data: Any) -> CLA:
-        """Convert a ComputerAgent action to a HUD action."""
-        try:
-            action_type = data.get("type")
-
-            if action_type == "click":
-                x, y = data.get("x", 0), data.get("y", 0)
-                button = data.get("button", "left")
-                button = self.BUTTON_MAP.get(button, button)
-                if button is None:
-                    button = "left"
-                converted_action = ClickAction(point=Point(x=x, y=y), button=button)
-
-            elif action_type == "double_click":
-                x, y = data.get("x", 0), data.get("y", 0)
-                converted_action = ClickAction(point=Point(x=x, y=y), button="left", pattern=[100])
-
-            elif action_type == "scroll":
-                x, y = int(data.get("x", 0)), int(data.get("y", 0))
-                scroll_x = int(data.get("scroll_x", 0))
-                scroll_y = int(data.get("scroll_y", 0))
-                converted_action = ScrollAction(
-                    point=Point(x=x, y=y), scroll=Point(x=scroll_x, y=scroll_y)
-                )
-
-            elif action_type == "type":
-                text = data.get("text", "")
-                converted_action = TypeAction(text=text, enter_after=False)
-
-            elif action_type == "wait":
-                ms = data.get("ms", 1000)
-                converted_action = WaitAction(time=ms)
-
-            elif action_type == "move":
-                x, y = data.get("x", 0), data.get("y", 0)
-                converted_action = MoveAction(point=Point(x=x, y=y))
-
-            elif action_type == "keypress":
-                keys = data.get("keys", [])
-                if isinstance(keys, str):
-                    keys = [keys]
-                converted_action = PressAction(keys=[self._map_key(k) for k in keys])
-
-            elif action_type == "drag":
-                path = data.get("path", [])
-                points = [Point(x=p.get("x", 0), y=p.get("y", 0)) for p in path]
-                converted_action = DragAction(path=points)
-
-            elif action_type == "screenshot":
-                converted_action = ScreenshotFetch()
-
-            elif action_type == "response":
-                converted_action = ResponseAction(text=data.get("text", ""))
-                
-            elif action_type == "custom":
-                converted_action = CustomAction(action=data.get("action", ""))
-                
-            else:
-                raise ValueError(f"Unsupported action type: {action_type}")
-
-            # Add reasoning and logs if available
-            converted_action.reasoning = data.get("reasoning", "")
-            converted_action.logs = data.get("logs", "")
-
-            return converted_action
-
-        except Exception as e:
-            raise ValueError(f"Invalid action: {data}. Error: {e!s}") from e