cua-agent 0.1.1__tar.gz → 0.1.3__tar.gz

{cua_agent-0.1.1 → cua_agent-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cua-agent
-Version: 0.1.1
+Version: 0.1.3
 Summary: CUA (Computer Use) Agent for AI-driven computer interaction
 Author-Email: TryCua <gh@trycua.com>
 Requires-Python: <3.13,>=3.10
@@ -13,6 +13,7 @@ Requires-Dist: pydantic<3.0.0,>=2.6.4
 Requires-Dist: rich<14.0.0,>=13.7.1
 Requires-Dist: python-dotenv<2.0.0,>=1.0.1
 Requires-Dist: cua-computer<0.2.0,>=0.1.0
+Requires-Dist: cua-core<0.2.0,>=0.1.0
 Requires-Dist: certifi>=2024.2.2
 Provides-Extra: anthropic
 Requires-Dist: anthropic>=0.49.0; extra == "anthropic"

{cua_agent-0.1.1 → cua_agent-0.1.3}/README.md

@@ -20,19 +20,19 @@
 ### Get started with Agent
 
 ```python
-from agent import ComputerAgent, AgenticLoop, APIProvider
+from agent import ComputerAgent, AgentLoop, LLMProvider
 from computer import Computer
 
 computer = Computer(verbosity=logging.INFO)
 
 agent = ComputerAgent(
     computer=computer,
-    api_key="<your-anthropic-api-key>",
-    loop_type=AgenticLoop.ANTHROPIC, # or AgenticLoop.OMNI
-    ai_provider=APIProvider.ANTHROPIC,
-    model='claude-3-7-sonnet-20250219',
+    loop=AgentLoop.ANTHROPIC,
+    # loop=AgentLoop.OMNI,
+    model=LLM(provider=LLMProvider.ANTHROPIC, name="claude-3-7-sonnet-20250219"),
+    # model=LLM(provider=LLMProvider.OPENAI, name="gpt-4.5-preview"),
     save_trajectory=True,
-    trajectory_dir=str(Path("trajectories") / datetime.now().strftime("%Y%m%d_%H%M%S")),
+    trajectory_dir=str(Path("trajectories")),
     only_n_most_recent_images=3,
     verbosity=logging.INFO,
 )

cua_agent-0.1.3/agent/__init__.py

@@ -0,0 +1,22 @@
+"""CUA (Computer Use) Agent for AI-driven computer interaction."""
+
+__version__ = "0.1.0"
+
+# Initialize telemetry when the package is imported
+try:
+    from core.telemetry import enable_telemetry, set_dimension
+
+    # Enable telemetry by default
+    enable_telemetry()
+    # Set the package version as a dimension
+    set_dimension("agent_version", __version__)
+except ImportError:
+    # Core telemetry not available
+    pass
+
+from .core.factory import AgentFactory
+from .core.agent import ComputerAgent
+from .providers.omni.types import LLMProvider, LLM
+from .types.base import Provider, AgentLoop
+
+__all__ = ["AgentFactory", "Provider", "ComputerAgent", "AgentLoop", "LLMProvider", "LLM"]

{cua_agent-0.1.1 → cua_agent-0.1.3}/agent/core/README.md

@@ -34,7 +34,7 @@ Here's how to use the unified ComputerAgent:
 ```python
 from agent.core.agent import ComputerAgent
 from agent.types.base import AgenticLoop
-from agent.providers.omni.types import APIProvider
+from agent.providers.omni.types import LLMProvider
 from computer import Computer
 
 # Create a Computer instance
@@ -44,7 +44,7 @@ computer = Computer()
 agent = ComputerAgent(
     computer=computer,
     loop_type=AgenticLoop.OMNI,
-    provider=APIProvider.OPENAI,
+    provider=LLMProvider.OPENAI,
     model="gpt-4o",
     api_key="your_api_key_here",  # Can also use OPENAI_API_KEY environment variable
     save_trajectory=True,

cua_agent-0.1.3/agent/core/agent.py

@@ -0,0 +1,259 @@
+"""Unified computer agent implementation that supports multiple loops."""
+
+import os
+import logging
+import asyncio
+import time
+import uuid
+from typing import Any, AsyncGenerator, Dict, List, Optional, TYPE_CHECKING, Union, cast
+from datetime import datetime
+from enum import Enum
+
+from computer import Computer
+
+from ..types.base import Provider, AgentLoop
+from .base_agent import BaseComputerAgent
+from ..core.telemetry import record_agent_initialization
+
+# Only import types for type checking to avoid circular imports
+if TYPE_CHECKING:
+    from ..providers.anthropic.loop import AnthropicLoop
+    from ..providers.omni.loop import OmniLoop
+    from ..providers.omni.parser import OmniParser
+
+# Import the provider types
+from ..providers.omni.types import LLMProvider, LLM, Model, LLMModel
+
+logger = logging.getLogger(__name__)
+
+# Default models for different providers
+DEFAULT_MODELS = {
+    LLMProvider.OPENAI: "gpt-4o",
+    LLMProvider.ANTHROPIC: "claude-3-7-sonnet-20250219",
+}
+
+# Map providers to their environment variable names
+ENV_VARS = {
+    LLMProvider.OPENAI: "OPENAI_API_KEY",
+    LLMProvider.ANTHROPIC: "ANTHROPIC_API_KEY",
+}
+
+
+class ComputerAgent(BaseComputerAgent):
+    """Unified implementation of the computer agent supporting multiple loop types.
+
+    This class consolidates the previous AnthropicComputerAgent and OmniComputerAgent
+    into a single implementation with configurable loop type.
+    """
+
+    def __init__(
+        self,
+        computer: Computer,
+        loop: AgentLoop = AgentLoop.OMNI,
+        model: Optional[Union[LLM, Dict[str, str], str]] = None,
+        api_key: Optional[str] = None,
+        save_trajectory: bool = True,
+        trajectory_dir: Optional[str] = "trajectories",
+        only_n_most_recent_images: Optional[int] = None,
+        max_retries: int = 3,
+        verbosity: int = logging.INFO,
+        telemetry_enabled: bool = True,
+        **kwargs,
+    ):
+        """Initialize a ComputerAgent instance.
+
+        Args:
+            computer: The Computer instance to control
+            loop: The agent loop to use: ANTHROPIC or OMNI
+            model: The model to use. Can be a string, dict or LLM object.
+                  Defaults to LLM for the loop type.
+            api_key: The API key to use. If None, will use environment variables.
+            save_trajectory: Whether to save the trajectory.
+            trajectory_dir: The directory to save trajectories to.
+            only_n_most_recent_images: Only keep this many most recent images.
+            max_retries: Maximum number of retries for failed requests.
+            verbosity: Logging level (standard Python logging levels).
+            telemetry_enabled: Whether to enable telemetry tracking. Defaults to True.
+            **kwargs: Additional keyword arguments to pass to the loop.
+        """
+        super().__init__(computer)
+        self._configure_logging(verbosity)
+        logger.info(f"Initializing ComputerAgent with {loop} loop")
+
+        # Store telemetry preference
+        self.telemetry_enabled = telemetry_enabled
+
+        # Pass telemetry preference to computer if available
+        if hasattr(computer, "telemetry_enabled"):
+            # Computer doesn't have a setter for telemetry_enabled
+            # Use disable_telemetry() method if telemetry is disabled
+            if not telemetry_enabled and hasattr(computer, "disable_telemetry"):
+                computer.disable_telemetry()
+
+        # Process the model configuration
+        self.model = self._process_model_config(model, loop)
+        self.loop_type = loop
+        self.api_key = api_key
+
+        # Store computer
+        self.computer = computer
+
+        # Save trajectory settings
+        self.save_trajectory = save_trajectory
+        self.trajectory_dir = trajectory_dir
+        self.only_n_most_recent_images = only_n_most_recent_images
+
+        # Store the max retries setting
+        self.max_retries = max_retries
+
+        # Initialize message history
+        self.messages = []
+
+        # Extra kwargs for the loop
+        self.loop_kwargs = kwargs
+
+        # Initialize the actual loop implementation
+        self.loop = self._init_loop()
+
+        # Record initialization in telemetry if enabled
+        if telemetry_enabled:
+            record_agent_initialization()
+
+    def _process_model_config(
+        self, model_input: Optional[Union[LLM, Dict[str, str], str]], loop: AgentLoop
+    ) -> LLM:
+        """Process and normalize model configuration.
+
+        Args:
+            model_input: Input model configuration (LLM, dict, string, or None)
+            loop: The loop type being used
+
+        Returns:
+            Normalized LLM instance
+        """
+        # Handle case where model_input is None
+        if model_input is None:
+            # Use Anthropic for Anthropic loop, OpenAI for Omni loop
+            default_provider = (
+                LLMProvider.ANTHROPIC if loop == AgentLoop.ANTHROPIC else LLMProvider.OPENAI
+            )
+            return LLM(provider=default_provider)
+
+        # Handle case where model_input is already a LLM or one of its aliases
+        if isinstance(model_input, (LLM, Model, LLMModel)):
+            return model_input
+
+        # Handle case where model_input is a dict
+        if isinstance(model_input, dict):
+            provider = model_input.get("provider", LLMProvider.OPENAI)
+            if isinstance(provider, str):
+                provider = LLMProvider(provider)
+            return LLM(provider=provider, name=model_input.get("name"))
+
+        # Handle case where model_input is a string (model name)
+        if isinstance(model_input, str):
+            default_provider = (
+                LLMProvider.ANTHROPIC if loop == AgentLoop.ANTHROPIC else LLMProvider.OPENAI
+            )
+            return LLM(provider=default_provider, name=model_input)
+
+        raise ValueError(f"Unsupported model configuration: {model_input}")
+
+    def _configure_logging(self, verbosity: int):
+        """Configure logging based on verbosity level."""
+        # Use the logging level directly without mapping
+        logger.setLevel(verbosity)
+        logging.getLogger("agent").setLevel(verbosity)
+
+        # Log the verbosity level that was set
+        if verbosity <= logging.DEBUG:
+            logger.info("Agent logging set to DEBUG level (full debug information)")
+        elif verbosity <= logging.INFO:
+            logger.info("Agent logging set to INFO level (standard output)")
+        elif verbosity <= logging.WARNING:
+            logger.warning("Agent logging set to WARNING level (warnings and errors only)")
+        elif verbosity <= logging.ERROR:
+            logger.warning("Agent logging set to ERROR level (errors only)")
+        elif verbosity <= logging.CRITICAL:
+            logger.warning("Agent logging set to CRITICAL level (critical errors only)")
+
+    def _init_loop(self) -> Any:
+        """Initialize the loop based on the loop_type.
+
+        Returns:
+            Initialized loop instance
+        """
+        # Lazy import OmniLoop and OmniParser to avoid circular imports
+        from ..providers.omni.loop import OmniLoop
+        from ..providers.omni.parser import OmniParser
+
+        if self.loop_type == AgentLoop.ANTHROPIC:
+            from ..providers.anthropic.loop import AnthropicLoop
+
+            # Ensure we always have a valid model name
+            model_name = self.model.name or DEFAULT_MODELS[LLMProvider.ANTHROPIC]
+
+            return AnthropicLoop(
+                api_key=self.api_key,
+                model=model_name,
+                computer=self.computer,
+                save_trajectory=self.save_trajectory,
+                base_dir=self.trajectory_dir,
+                only_n_most_recent_images=self.only_n_most_recent_images,
+                **self.loop_kwargs,
+            )
+
+        # Initialize parser for OmniLoop with appropriate device
+        if "parser" not in self.loop_kwargs:
+            self.loop_kwargs["parser"] = OmniParser()
+
+        # Ensure we always have a valid model name
+        model_name = self.model.name or DEFAULT_MODELS[self.model.provider]
+
+        return OmniLoop(
+            provider=self.model.provider,
+            api_key=self.api_key,
+            model=model_name,
+            computer=self.computer,
+            save_trajectory=self.save_trajectory,
+            base_dir=self.trajectory_dir,
+            only_n_most_recent_images=self.only_n_most_recent_images,
+            **self.loop_kwargs,
+        )
+
+    async def _execute_task(self, task: str) -> AsyncGenerator[Dict[str, Any], None]:
+        """Execute a task using the appropriate agent loop.
+
+        Args:
+            task: The task to execute
+
+        Returns:
+            AsyncGenerator yielding task outputs
+        """
+        logger.info(f"Executing task: {task}")
+
+        try:
+            # Create a message from the task
+            task_message = {"role": "user", "content": task}
+            messages_with_task = self.messages + [task_message]
+
+            # Use the run method of the loop
+            async for output in self.loop.run(messages_with_task):
+                yield output
+        except Exception as e:
+            logger.error(f"Error executing task: {e}")
+            raise
+        finally:
+            pass
+
+    async def _execute_action(self, action_type: str, **action_params) -> Any:
+        """Execute an action with telemetry tracking."""
+        try:
+            # Execute the action
+            result = await super()._execute_action(action_type, **action_params)
+            return result
+        except Exception as e:
+            logger.exception(f"Error executing action {action_type}: {e}")
+            raise
+        finally:
+            pass

{cua_agent-0.1.1 → cua_agent-0.1.3}/agent/core/base_agent.py

@@ -113,7 +113,7 @@ class BaseComputerAgent(ABC):
             # Take a test screenshot to verify the computer is working
             logger.info("Testing computer with a screenshot...")
             try:
-                test_screenshot = await self.computer.screenshot()
+                test_screenshot = await self.computer.interface.screenshot()
                 # Determine the screenshot size based on its type
                 if isinstance(test_screenshot, bytes):
                     size = len(test_screenshot)

{cua_agent-0.1.1 → cua_agent-0.1.3}/agent/core/experiment.py

@@ -8,6 +8,7 @@ from datetime import datetime
 from typing import Any, Dict, List, Optional
 from PIL import Image
 import json
+import re
 
 logger = logging.getLogger(__name__)
 
@@ -106,9 +107,18 @@ class ExperimentManager:
             # Increment screenshot counter
             self.screenshot_count += 1
 
+            # Sanitize action_type to ensure valid filename
+            # Replace characters that are not safe for filenames
+            sanitized_action = ""
+            if action_type:
+                # Replace invalid filename characters with underscores
+                sanitized_action = re.sub(r'[\\/*?:"<>|]', "_", action_type)
+                # Limit the length to avoid excessively long filenames
+                sanitized_action = sanitized_action[:50]
+
             # Create a descriptive filename
             timestamp = int(datetime.now().timestamp() * 1000)
-            action_suffix = f"_{action_type}" if action_type else ""
+            action_suffix = f"_{sanitized_action}" if sanitized_action else ""
             filename = f"screenshot_{self.screenshot_count:03d}{action_suffix}_{timestamp}.png"
 
             # Save directly to the turn directory

{cua_agent-0.1.1 → cua_agent-0.1.3}/agent/core/loop.py

@@ -166,7 +166,7 @@ class BaseLoop(ABC):
         """
         try:
             # Take screenshot
-            screenshot = await self.computer.screenshot()
+            screenshot = await self.computer.interface.screenshot()
 
             # Initialize with default values
             width, height = 1024, 768

cua_agent-0.1.3/agent/core/telemetry.py

@@ -0,0 +1,138 @@
+"""Agent telemetry for tracking anonymous usage and feature usage."""
+
+import logging
+import os
+import platform
+import sys
+import time
+from typing import Dict, Any, Optional
+
+# Import the core telemetry module
+TELEMETRY_AVAILABLE = False
+
+try:
+    from core.telemetry import (
+        record_event,
+        increment,
+        get_telemetry_client,
+        flush,
+        is_telemetry_enabled,
+        is_telemetry_globally_disabled,
+    )
+
+    def increment_counter(counter_name: str, value: int = 1) -> None:
+        """Wrapper for increment to maintain backward compatibility."""
+        if is_telemetry_enabled():
+            increment(counter_name, value)
+
+    def set_dimension(name: str, value: Any) -> None:
+        """Set a dimension that will be attached to all events."""
+        logger = logging.getLogger("cua.agent.telemetry")
+        logger.debug(f"Setting dimension {name}={value}")
+
+    TELEMETRY_AVAILABLE = True
+    logger = logging.getLogger("cua.agent.telemetry")
+    logger.info("Successfully imported telemetry")
+except ImportError as e:
+    logger = logging.getLogger("cua.agent.telemetry")
+    logger.warning(f"Could not import telemetry: {e}")
+    TELEMETRY_AVAILABLE = False
+
+
+# Local fallbacks in case core telemetry isn't available
+def _noop(*args: Any, **kwargs: Any) -> None:
+    """No-op function for when telemetry is not available."""
+    pass
+
+
+logger = logging.getLogger("cua.agent.telemetry")
+
+# If telemetry isn't available, use no-op functions
+if not TELEMETRY_AVAILABLE:
+    logger.debug("Telemetry not available, using no-op functions")
+    record_event = _noop  # type: ignore
+    increment_counter = _noop  # type: ignore
+    set_dimension = _noop  # type: ignore
+    get_telemetry_client = lambda: None  # type: ignore
+    flush = _noop  # type: ignore
+    is_telemetry_enabled = lambda: False  # type: ignore
+    is_telemetry_globally_disabled = lambda: True  # type: ignore
+
+# Get system info once to use in telemetry
+SYSTEM_INFO = {
+    "os": platform.system().lower(),
+    "os_version": platform.release(),
+    "python_version": platform.python_version(),
+}
+
+
+def enable_telemetry() -> bool:
+    """Enable telemetry if available.
+
+    Returns:
+        bool: True if telemetry was successfully enabled, False otherwise
+    """
+    global TELEMETRY_AVAILABLE
+
+    # Check if globally disabled using core function
+    if TELEMETRY_AVAILABLE and is_telemetry_globally_disabled():
+        logger.info("Telemetry is globally disabled via environment variable - cannot enable")
+        return False
+
+    # Already enabled
+    if TELEMETRY_AVAILABLE:
+        return True
+
+    # Try to import and enable
+    try:
+        from core.telemetry import (
+            record_event,
+            increment,
+            get_telemetry_client,
+            flush,
+            is_telemetry_globally_disabled,
+        )
+
+        # Check again after import
+        if is_telemetry_globally_disabled():
+            logger.info("Telemetry is globally disabled via environment variable - cannot enable")
+            return False
+
+        TELEMETRY_AVAILABLE = True
+        logger.info("Telemetry successfully enabled")
+        return True
+    except ImportError as e:
+        logger.warning(f"Could not enable telemetry: {e}")
+        return False
+
+
+def disable_telemetry() -> None:
+    """Disable telemetry for this session."""
+    global TELEMETRY_AVAILABLE
+    TELEMETRY_AVAILABLE = False
+    logger.info("Telemetry disabled for this session")
+
+
+def is_telemetry_enabled() -> bool:
+    """Check if telemetry is enabled.
+
+    Returns:
+        bool: True if telemetry is enabled, False otherwise
+    """
+    # Use the core function if available, otherwise use our local flag
+    if TELEMETRY_AVAILABLE:
+        from core.telemetry import is_telemetry_enabled as core_is_enabled
+
+        return core_is_enabled()
+    return False
+
+
+def record_agent_initialization() -> None:
+    """Record when an agent instance is initialized."""
+    if TELEMETRY_AVAILABLE and is_telemetry_enabled():
+        record_event("agent_initialized", SYSTEM_INFO)
+
+        # Set dimensions that will be attached to all events
+        set_dimension("os", SYSTEM_INFO["os"])
+        set_dimension("os_version", SYSTEM_INFO["os_version"])
+        set_dimension("python_version", SYSTEM_INFO["python_version"])

{cua_agent-0.1.1 → cua_agent-0.1.3}/agent/providers/anthropic/__init__.py

@@ -1,6 +1,6 @@
 """Anthropic provider implementation."""
 
 from .loop import AnthropicLoop
-from .types import APIProvider
+from .types import LLMProvider
 
-__all__ = ["AnthropicLoop", "APIProvider"]
+__all__ = ["AnthropicLoop", "LLMProvider"]