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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cua-agent
-Version: 0.1.2
+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.2 → cua_agent-0.1.3}/agent/__init__.py

@@ -2,6 +2,18 @@
 
 __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

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.2 → 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.2 → 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.2 → 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.2 → cua_agent-0.1.3}/agent/providers/omni/loop.py

@@ -731,7 +731,7 @@ class OmniLoop(BaseLoop):
                         action_type = f"hotkey_{content['Value'].replace('+', '_')}"
                     logger.info(f"Preparing hotkey with keys: {keys}")
                     # Get the method but call it with *args instead of **kwargs
-                    method = getattr(self.computer, action)
+                    method = getattr(self.computer.interface, action)
                     await method(*keys)  # Unpack the keys list as positional arguments
                     logger.info(f"Tool execution completed successfully: {action}")
 
@@ -776,7 +776,7 @@ class OmniLoop(BaseLoop):
 
                 # Execute tool and handle result
                 try:
-                    method = getattr(self.computer, action)
+                    method = getattr(self.computer.interface, action)
                     logger.info(f"Found method for action '{action}': {method}")
                     await method(**kwargs)
                     logger.info(f"Tool execution completed successfully: {action}")

{cua_agent-0.1.2 → cua_agent-0.1.3}/agent/providers/omni/parser.py

@@ -79,7 +79,7 @@ class OmniParser:
         try:
             # Get screenshot from computer
             logger.info("Taking screenshot...")
-            screenshot = await computer.screenshot()
+            screenshot = await computer.interface.screenshot()
 
             # Log screenshot info
             logger.info(f"Screenshot type: {type(screenshot)}")

{cua_agent-0.1.2 → cua_agent-0.1.3}/agent/providers/omni/types.py

@@ -10,8 +10,6 @@ class LLMProvider(StrEnum):
 
     ANTHROPIC = "anthropic"
     OPENAI = "openai"
-    GROQ = "groq"
-    QWEN = "qwen"
 
 
 LLMProvider
@@ -39,14 +37,10 @@ Model = LLM
 PROVIDER_TO_DEFAULT_MODEL: Dict[LLMProvider, str] = {
     LLMProvider.ANTHROPIC: "claude-3-7-sonnet-20250219",
     LLMProvider.OPENAI: "gpt-4o",
-    LLMProvider.GROQ: "deepseek-r1-distill-llama-70b",
-    LLMProvider.QWEN: "qwen2.5-vl-72b-instruct",
 }
 
 # Environment variable names for each provider
 PROVIDER_TO_ENV_VAR: Dict[LLMProvider, str] = {
     LLMProvider.ANTHROPIC: "ANTHROPIC_API_KEY",
     LLMProvider.OPENAI: "OPENAI_API_KEY",
-    LLMProvider.GROQ: "GROQ_API_KEY",
-    LLMProvider.QWEN: "QWEN_API_KEY",
 }

cua_agent-0.1.3/agent/telemetry.py

@@ -0,0 +1,21 @@
+"""Telemetry support for Agent class."""
+
+import os
+import platform
+import sys
+import time
+from typing import Any, Dict, Optional
+
+from core.telemetry import (
+    record_event,
+    is_telemetry_enabled,
+    flush,
+    get_telemetry_client,
+    increment,
+)
+
+# System information used for telemetry
+SYSTEM_INFO = {
+    "os": sys.platform,
+    "python_version": platform.python_version(),
+}

{cua_agent-0.1.2 → cua_agent-0.1.3}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "pdm.backend"
 
 [project]
 name = "cua-agent"
-version = "0.1.2"
+version = "0.1.3"
 description = "CUA (Computer Use) Agent for AI-driven computer interaction"
 authors = [
     { name = "TryCua", email = "gh@trycua.com" },
@@ -21,6 +21,7 @@ dependencies = [
     "rich>=13.7.1,<14.0.0",
     "python-dotenv>=1.0.1,<2.0.0",
     "cua-computer>=0.1.0,<0.2.0",
+    "cua-core>=0.1.0,<0.2.0",
     "certifi>=2024.2.2",
 ]
 requires-python = ">=3.10,<3.13"
@@ -78,7 +79,7 @@ target-version = [
 
 [tool.ruff]
 line-length = 100
-target-version = "0.1.2"
+target-version = "0.1.3"
 select = [
     "E",
     "F",
@@ -92,7 +93,7 @@ docstring-code-format = true
 
 [tool.mypy]
 strict = true
-python_version = "0.1.2"
+python_version = "0.1.3"
 ignore_missing_imports = true
 disallow_untyped_defs = true
 check_untyped_defs = true

cua_agent-0.1.2/agent/core/agent.py

@@ -1,327 +0,0 @@
-"""Unified computer agent implementation that supports multiple loops."""
-
-import os
-import logging
-import asyncio
-from typing import Any, AsyncGenerator, Dict, List, Optional, TYPE_CHECKING, Union, cast
-from datetime import datetime
-
-from computer import Computer
-
-from ..types.base import Provider, AgentLoop
-from .base_agent import BaseComputerAgent
-
-# 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",
-    LLMProvider.GROQ: "llama3-70b-8192",
-}
-
-# Map providers to their environment variable names
-ENV_VARS = {
-    LLMProvider.OPENAI: "OPENAI_API_KEY",
-    LLMProvider.GROQ: "GROQ_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,
-        **kwargs,
-    ):
-        """Initialize the computer agent.
-
-        Args:
-            computer: Computer instance to control
-            loop: The type of loop to use (Anthropic or Omni)
-            model: LLM configuration. Can be:
-                  - LLM object with provider and name
-                  - Dict with 'provider' and 'name' keys
-                  - String with model name (defaults to OpenAI provider)
-                  - None (defaults based on loop)
-            api_key: Optional API key (will use environment variable if not provided)
-            save_trajectory: Whether to save screenshots and logs
-            trajectory_dir: Directory to save trajectories (defaults to "trajectories")
-            only_n_most_recent_images: Limit history to N most recent images
-            max_retries: Maximum number of retry attempts for failed operations
-            verbosity: Logging level (standard Python logging levels: logging.DEBUG, logging.INFO, etc.)
-            **kwargs: Additional keyword arguments to pass to the loop
-        """
-        # Set up trajectory directories based on save_trajectory
-        base_dir = trajectory_dir if save_trajectory else None
-        # Don't create a redundant screenshots directory - directly use the timestamp folder
-        screenshot_dir = None  # This was previously set to os.path.join(base_dir, "screenshots")
-        log_dir = None
-
-        super().__init__(
-            max_retries=max_retries,
-            computer=computer,
-            screenshot_dir=screenshot_dir,
-            log_dir=log_dir,
-            **kwargs,
-        )
-
-        self.loop_type = loop
-        self.save_trajectory = save_trajectory
-        self.trajectory_dir = trajectory_dir
-        self.only_n_most_recent_images = only_n_most_recent_images
-        self.verbosity = verbosity
-        self._kwargs = kwargs  # Keep this for loop initialization
-
-        # Configure logging based on verbosity
-        self._configure_logging(verbosity)
-
-        # Process model configuration
-        self.model_config = self._process_model_config(model, loop)
-
-        # Get API key from environment if not provided
-        if api_key is None:
-            env_var = (
-                ENV_VARS.get(self.model_config.provider)
-                if loop == AgentLoop.OMNI
-                else "ANTHROPIC_API_KEY"
-            )
-            if not env_var:
-                raise ValueError(
-                    f"Unsupported provider: {self.model_config.provider}. Please use one of: {list(ENV_VARS.keys())}"
-                )
-
-            api_key = os.environ.get(env_var)
-            if not api_key:
-                raise ValueError(
-                    f"No API key provided and {env_var} environment variable is not set.\n"
-                    f"Please set the {env_var} environment variable or pass the api_key directly:\n"
-                    f"  - Export in terminal: export {env_var}=your_api_key_here\n"
-                    f"  - Add to .env file: {env_var}=your_api_key_here\n"
-                    f"  - Pass directly: api_key='your_api_key_here'"
-                )
-        self.api_key = api_key
-
-        # Initialize the appropriate loop based on loop_type
-        self.loop = self._init_loop()
-
-    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_config.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._kwargs,
-            )
-
-        # Initialize parser for OmniLoop with appropriate device
-        if "parser" not in self._kwargs:
-            self._kwargs["parser"] = OmniParser()
-
-        # Ensure we always have a valid model name
-        model_name = self.model_config.name or DEFAULT_MODELS[self.model_config.provider]
-
-        return OmniLoop(
-            provider=self.model_config.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._kwargs,
-        )
-
-    async def _execute_task(self, task: str) -> AsyncGenerator[Dict[str, Any], None]:
-        """Execute a task using the appropriate loop.
-
-        Args:
-            task: Task description to execute
-
-        Yields:
-            Dict containing response content and metadata
-        """
-        try:
-            # Format the messages based on loop type
-            if self.loop_type == AgentLoop.ANTHROPIC:
-                # Anthropic format
-                messages = [{"role": "user", "content": [{"type": "text", "text": task}]}]
-            else:
-                # Cua format
-                messages = [{"role": "user", "content": task}]
-
-            # Run the loop
-            try:
-                async for result in self.loop.run(messages):
-                    if result is None:
-                        break
-
-                    # Handle error case
-                    if "error" in result:
-                        yield {
-                            "role": "assistant",
-                            "content": result["error"],
-                            "metadata": {"title": "❌ Error"},
-                        }
-                        continue
-
-                    # Extract content and metadata based on loop type
-                    if self.loop_type == AgentLoop.ANTHROPIC:
-                        # Handle Anthropic format
-                        if "content" in result:
-                            content_text = ""
-                            for content_block in result["content"]:
-                                try:
-                                    # Try to access the text attribute directly
-                                    content_text += content_block.text
-                                except (AttributeError, TypeError):
-                                    # If it's a dictionary instead of an object
-                                    if isinstance(content_block, dict) and "text" in content_block:
-                                        content_text += content_block["text"]
-
-                            yield {
-                                "role": "assistant",
-                                "content": content_text,
-                                "metadata": result.get("parsed_screen", {}),
-                            }
-                        else:
-                            yield {
-                                "role": "assistant",
-                                "content": str(result),
-                                "metadata": {"title": "Screen Analysis"},
-                            }
-                    else:
-                        # Handle Omni format
-                        content = ""
-                        metadata = {"title": "Screen Analysis"}
-
-                        # If result has content (normal case)
-                        if "content" in result:
-                            content = result["content"]
-
-                            # Ensure metadata has a title
-                            if isinstance(content, dict) and "metadata" in content:
-                                metadata = content["metadata"]
-                                if "title" not in metadata:
-                                    metadata["title"] = "Screen Analysis"
-
-                            # For string content, convert to proper format
-                            if isinstance(content, str):
-                                content = content
-                            elif isinstance(content, dict) and "content" in content:
-                                content = content.get("content", "")
-
-                        yield {"role": "assistant", "content": content, "metadata": metadata}
-            except Exception as e:
-                logger.error(f"Error running the loop: {str(e)}")
-                yield {
-                    "role": "assistant",
-                    "content": f"Error running the agent loop: {str(e)}",
-                    "metadata": {"title": "❌ Loop Error"},
-                }
-
-        except Exception as e:
-            logger.error(f"Error in _execute_task: {str(e)}")
-            yield {
-                "role": "assistant",
-                "content": f"Error: {str(e)}",
-                "metadata": {"title": "❌ Error"},
-            }