cua-agent 0.4.22__py3-none-any.whl → 0.7.16__py3-none-any.whl

agent/proxy/handlers.py

@@ -2,29 +2,34 @@
 Request handlers for the proxy endpoints.
 """
 
-import asyncio
 import json
 import logging
 import os
+import re
 from contextlib import contextmanager
-from typing import Dict, Any, List, Union, Optional
+from typing import Any, Dict, List, Optional, Union
 
-from ..agent import ComputerAgent
 from computer import Computer
 
+from ..agent import ComputerAgent
+from ..tools.browser_tool import BrowserTool
+
 logger = logging.getLogger(__name__)
 
+# Pattern to detect FARA models (case-insensitive)
+FARA_MODEL_PATTERN = re.compile(r"(?i).*fara.*")
+
 
 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,
@@ -75,7 +80,9 @@ class ResponsesHandler:
                 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}")
+                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}")
 
@@ -88,41 +95,51 @@ class ResponsesHandler:
         agent_key_payload = {"model": model, **agent_kwargs_for_key}
         agent_key = _stable_key(agent_key_payload)
 
+        # Determine the appropriate tool based on model type
+        # FARA models require BrowserTool instead of Computer for browser-specific actions
+        # (visit_url, web_search, terminate, history_back, etc.)
+        is_fara_model = bool(FARA_MODEL_PATTERN.match(model))
+        if is_fara_model and computer is not None:
+            tool = BrowserTool(interface=computer.interface)
+            logger.info(f"Using BrowserTool for FARA model: {model}")
+        else:
+            tool = computer
+
         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]
+                default_a_config["tools"] = [tool]
             # Apply user overrides, but keep tools unless user explicitly sets
             if agent_kwargs:
                 if not has_custom_tools:
-                    agent_kwargs.setdefault("tools", [computer])
+                    agent_kwargs.setdefault("tools", [tool])
                 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)
+            # Ensure cached agent uses the current tool (in case object differs)
             # Only update if tools not explicitly provided in agent_kwargs
             if not has_custom_tools:
                 try:
-                    agent.tools = [computer]
+                    agent.tools = [tool]
                 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
         """
@@ -133,12 +150,12 @@ class ResponsesHandler:
             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
@@ -155,28 +172,22 @@ class ResponsesHandler:
                 # 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
-                    }
-                
+                    return {"success": True, "result": result, "model": model}
+
             # If no results were yielded
-            return {
-                "success": False,
-                "error": "No results from agent",
-                "model": model
-            }
-            
+            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")
+                "model": request_data.get("model", "unknown"),
             }
-    
-    def _convert_input_to_messages(self, input_data: Union[str, List[Dict[str, Any]]]) -> List[Dict[str, Any]]:
+
+    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
@@ -192,22 +203,18 @@ class ResponsesHandler:
                         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"]}
-                            })
+                            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
-                    })
+                    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: