cua-agent 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

agent/__init__.py

@@ -2,9 +2,21 @@
 
 __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 .types.base import Provider, AgenticLoop
-from .providers.omni.types import LLMProvider, LLM, Model, LLMModel, APIProvider
+from .providers.omni.types import LLMProvider, LLM
+from .types.base import Provider, AgentLoop
 
-__all__ = ["AgentFactory", "Provider", "ComputerAgent", "AgenticLoop", "LLMProvider", "LLM", "Model", "LLMModel", "APIProvider"]
+__all__ = ["AgentFactory", "Provider", "ComputerAgent", "AgentLoop", "LLMProvider", "LLM"]

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,

agent/core/agent.py

@@ -3,13 +3,17 @@
 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, AgenticLoop
+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:
@@ -18,7 +22,7 @@ if TYPE_CHECKING:
     from ..providers.omni.parser import OmniParser
 
 # Import the provider types
-from ..providers.omni.types import LLMProvider, LLM, Model, LLMModel, APIProvider
+from ..providers.omni.types import LLMProvider, LLM, Model, LLMModel
 
 logger = logging.getLogger(__name__)
 
@@ -26,13 +30,11 @@ logger = logging.getLogger(__name__)
 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",
 }
 
@@ -47,7 +49,7 @@ class ComputerAgent(BaseComputerAgent):
     def __init__(
         self,
         computer: Computer,
-        loop_type: AgenticLoop = AgenticLoop.OMNI,
+        loop: AgentLoop = AgentLoop.OMNI,
         model: Optional[Union[LLM, Dict[str, str], str]] = None,
         api_key: Optional[str] = None,
         save_trajectory: bool = True,
@@ -55,88 +57,77 @@ class ComputerAgent(BaseComputerAgent):
         only_n_most_recent_images: Optional[int] = None,
         max_retries: int = 3,
         verbosity: int = logging.INFO,
+        telemetry_enabled: bool = True,
         **kwargs,
     ):
-        """Initialize the computer agent.
+        """Initialize a ComputerAgent instance.
 
         Args:
-            computer: Computer instance to control
-            loop_type: 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_type)
-            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
+            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.
         """
-        # 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,
-        )
+        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
 
-        self.loop_type = loop_type
+        # Save trajectory settings
         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)
+        # Store the max retries setting
+        self.max_retries = max_retries
 
-        # Process model configuration
-        self.model_config = self._process_model_config(model, loop_type)
-        
-        # Get API key from environment if not provided
-        if api_key is None:
-            env_var = (
-                ENV_VARS.get(self.model_config.provider) 
-                if loop_type == AgenticLoop.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 message history
+        self.messages = []
+
+        # Extra kwargs for the loop
+        self.loop_kwargs = kwargs
 
-        # Initialize the appropriate loop based on loop_type
+        # 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_type: AgenticLoop
+        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_type: The loop type being used
-            
+            loop: The loop type being used
+
         Returns:
             Normalized LLM instance
         """
@@ -144,31 +135,28 @@ class ComputerAgent(BaseComputerAgent):
         if model_input is None:
             # Use Anthropic for Anthropic loop, OpenAI for Omni loop
             default_provider = (
-                LLMProvider.ANTHROPIC if loop_type == AgenticLoop.ANTHROPIC else LLMProvider.OPENAI
+                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")
-            )
-            
+            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_type == AgenticLoop.ANTHROPIC else LLMProvider.OPENAI
+                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):
@@ -199,12 +187,12 @@ class ComputerAgent(BaseComputerAgent):
         from ..providers.omni.loop import OmniLoop
         from ..providers.omni.parser import OmniParser
 
-        if self.loop_type == AgenticLoop.ANTHROPIC:
+        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]
-            
+            model_name = self.model.name or DEFAULT_MODELS[LLMProvider.ANTHROPIC]
+
             return AnthropicLoop(
                 api_key=self.api_key,
                 model=model_name,
@@ -212,119 +200,60 @@ class ComputerAgent(BaseComputerAgent):
                 save_trajectory=self.save_trajectory,
                 base_dir=self.trajectory_dir,
                 only_n_most_recent_images=self.only_n_most_recent_images,
-                **self._kwargs,
+                **self.loop_kwargs,
             )
 
         # Initialize parser for OmniLoop with appropriate device
-        if "parser" not in self._kwargs:
-            self._kwargs["parser"] = OmniParser()
+        if "parser" not in self.loop_kwargs:
+            self.loop_kwargs["parser"] = OmniParser()
 
         # Ensure we always have a valid model name
-        model_name = self.model_config.name or DEFAULT_MODELS[self.model_config.provider]
-        
+        model_name = self.model.name or DEFAULT_MODELS[self.model.provider]
+
         return OmniLoop(
-            provider=self.model_config.provider,
+            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._kwargs,
+            **self.loop_kwargs,
         )
 
     async def _execute_task(self, task: str) -> AsyncGenerator[Dict[str, Any], None]:
-        """Execute a task using the appropriate loop.
+        """Execute a task using the appropriate agent loop.
 
         Args:
-            task: Task description to execute
+            task: The task to execute
 
-        Yields:
-            Dict containing response content and metadata
+        Returns:
+            AsyncGenerator yielding task outputs
         """
+        logger.info(f"Executing task: {task}")
+
         try:
-            # Format the messages based on loop type
-            if self.loop_type == AgenticLoop.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 == AgenticLoop.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"},
-                }
+            # 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.error(f"Error in _execute_task: {str(e)}")
-            yield {
-                "role": "assistant",
-                "content": f"Error: {str(e)}",
-                "metadata": {"title": "❌ Error"},
-            }
+            logger.exception(f"Error executing action {action_type}: {e}")
+            raise
+        finally:
+            pass

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)

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

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

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"])

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"]

agent/providers/anthropic/api/client.py

@@ -3,25 +3,28 @@ import httpx
 import asyncio
 from anthropic import Anthropic, AnthropicBedrock, AnthropicVertex
 from anthropic.types.beta import BetaMessage, BetaMessageParam, BetaToolUnionParam
-from ..types import APIProvider
+from ..types import LLMProvider
 from .logging import log_api_interaction
 import random
 import logging
 
 logger = logging.getLogger(__name__)
 
+
 class APIConnectionError(Exception):
     """Error raised when there are connection issues with the API."""
+
     pass
 
+
 class BaseAnthropicClient:
     """Base class for Anthropic API clients."""
-    
+
     MAX_RETRIES = 10
     INITIAL_RETRY_DELAY = 1.0
     MAX_RETRY_DELAY = 60.0
     JITTER_FACTOR = 0.1
-    
+
     async def create_message(
         self,
         *,
@@ -36,79 +39,67 @@ class BaseAnthropicClient:
 
     async def _make_api_call_with_retries(self, api_call):
         """Make an API call with exponential backoff retry logic.
-        
+
         Args:
             api_call: Async function that makes the actual API call
-            
+
         Returns:
             API response
-            
+
         Raises:
             APIConnectionError: If all retries fail
         """
         retry_count = 0
         last_error = None
-        
+
         while retry_count < self.MAX_RETRIES:
             try:
                 return await api_call()
             except Exception as e:
                 last_error = e
                 retry_count += 1
-                
+
                 if retry_count == self.MAX_RETRIES:
                     break
-                    
+
                 # Calculate delay with exponential backoff and jitter
                 delay = min(
-                    self.INITIAL_RETRY_DELAY * (2 ** (retry_count - 1)),
-                    self.MAX_RETRY_DELAY
+                    self.INITIAL_RETRY_DELAY * (2 ** (retry_count - 1)), self.MAX_RETRY_DELAY
                 )
                 # Add jitter to avoid thundering herd
                 jitter = delay * self.JITTER_FACTOR * (2 * random.random() - 1)
                 final_delay = delay + jitter
-                
+
                 logger.info(
                     f"Retrying request (attempt {retry_count}/{self.MAX_RETRIES}) "
                     f"in {final_delay:.2f} seconds after error: {str(e)}"
                 )
                 await asyncio.sleep(final_delay)
-        
+
         raise APIConnectionError(
-            f"Failed after {self.MAX_RETRIES} retries. "
-            f"Last error: {str(last_error)}"
+            f"Failed after {self.MAX_RETRIES} retries. " f"Last error: {str(last_error)}"
         )
 
+
 class AnthropicDirectClient(BaseAnthropicClient):
     """Direct Anthropic API client implementation."""
-    
+
     def __init__(self, api_key: str, model: str):
         self.model = model
-        self.client = Anthropic(
-            api_key=api_key,
-            http_client=self._create_http_client()
-        )
-    
+        self.client = Anthropic(api_key=api_key, http_client=self._create_http_client())
+
     def _create_http_client(self) -> httpx.Client:
         """Create an HTTP client with appropriate settings."""
         return httpx.Client(
             verify=True,
-            timeout=httpx.Timeout(
-                connect=30.0,
-                read=300.0,
-                write=30.0,
-                pool=30.0
-            ),
+            timeout=httpx.Timeout(connect=30.0, read=300.0, write=30.0, pool=30.0),
             transport=httpx.HTTPTransport(
                 retries=3,
                 verify=True,
-                limits=httpx.Limits(
-                    max_keepalive_connections=5,
-                    max_connections=10
-                )
-            )
+                limits=httpx.Limits(max_keepalive_connections=5, max_connections=10),
+            ),
         )
-    
+
     async def create_message(
         self,
         *,
@@ -119,6 +110,7 @@ class AnthropicDirectClient(BaseAnthropicClient):
         betas: list[str],
     ) -> BetaMessage:
         """Create a message using the direct Anthropic API with retry logic."""
+
         async def api_call():
             response = self.client.beta.messages.with_raw_response.create(
                 max_tokens=max_tokens,
@@ -130,20 +122,21 @@ class AnthropicDirectClient(BaseAnthropicClient):
             )
             log_api_interaction(response.http_response.request, response.http_response, None)
             return response.parse()
-            
+
         try:
             return await self._make_api_call_with_retries(api_call)
         except Exception as e:
             log_api_interaction(None, None, e)
             raise
 
+
 class AnthropicVertexClient(BaseAnthropicClient):
     """Google Cloud Vertex AI implementation of Anthropic client."""
-    
+
     def __init__(self, model: str):
         self.model = model
         self.client = AnthropicVertex()
-    
+
     async def create_message(
         self,
         *,
@@ -154,6 +147,7 @@ class AnthropicVertexClient(BaseAnthropicClient):
         betas: list[str],
     ) -> BetaMessage:
         """Create a message using Vertex AI with retry logic."""
+
         async def api_call():
             response = self.client.beta.messages.with_raw_response.create(
                 max_tokens=max_tokens,
@@ -165,20 +159,21 @@ class AnthropicVertexClient(BaseAnthropicClient):
             )
             log_api_interaction(response.http_response.request, response.http_response, None)
             return response.parse()
-            
+
         try:
             return await self._make_api_call_with_retries(api_call)
         except Exception as e:
             log_api_interaction(None, None, e)
             raise
 
+
 class AnthropicBedrockClient(BaseAnthropicClient):
     """AWS Bedrock implementation of Anthropic client."""
-    
+
     def __init__(self, model: str):
         self.model = model
         self.client = AnthropicBedrock()
-    
+
     async def create_message(
         self,
         *,
@@ -189,6 +184,7 @@ class AnthropicBedrockClient(BaseAnthropicClient):
         betas: list[str],
     ) -> BetaMessage:
         """Create a message using AWS Bedrock with retry logic."""
+
         async def api_call():
             response = self.client.beta.messages.with_raw_response.create(
                 max_tokens=max_tokens,
@@ -200,23 +196,24 @@ class AnthropicBedrockClient(BaseAnthropicClient):
             )
             log_api_interaction(response.http_response.request, response.http_response, None)
             return response.parse()
-            
+
         try:
             return await self._make_api_call_with_retries(api_call)
         except Exception as e:
             log_api_interaction(None, None, e)
             raise
 
+
 class AnthropicClientFactory:
     """Factory for creating appropriate Anthropic client implementations."""
-    
+
     @staticmethod
-    def create_client(provider: APIProvider, api_key: str, model: str) -> BaseAnthropicClient:
+    def create_client(provider: LLMProvider, api_key: str, model: str) -> BaseAnthropicClient:
         """Create an appropriate client based on the provider."""
-        if provider == APIProvider.ANTHROPIC:
+        if provider == LLMProvider.ANTHROPIC:
             return AnthropicDirectClient(api_key, model)
-        elif provider == APIProvider.VERTEX:
+        elif provider == LLMProvider.VERTEX:
             return AnthropicVertexClient(model)
-        elif provider == APIProvider.BEDROCK:
+        elif provider == LLMProvider.BEDROCK:
             return AnthropicBedrockClient(model)
-        raise ValueError(f"Unsupported provider: {provider}") 
+        raise ValueError(f"Unsupported provider: {provider}")

agent/providers/anthropic/loop.py

@@ -32,7 +32,7 @@ from .tools.manager import ToolManager
 from .messages.manager import MessageManager
 from .callbacks.manager import CallbackManager
 from .prompts import SYSTEM_PROMPT
-from .types import APIProvider
+from .types import LLMProvider
 from .tools import ToolResult
 
 # Constants
@@ -86,7 +86,7 @@ class AnthropicLoop(BaseLoop):
         self.model = "claude-3-7-sonnet-20250219"
 
         # Anthropic-specific attributes
-        self.provider = APIProvider.ANTHROPIC
+        self.provider = LLMProvider.ANTHROPIC
         self.client = None
         self.retry_count = 0
         self.tool_manager = None

agent/providers/anthropic/types.py

@@ -1,7 +1,7 @@
 from enum import StrEnum
 
 
-class APIProvider(StrEnum):
+class LLMProvider(StrEnum):
     """Enum for supported API providers."""
 
     ANTHROPIC = "anthropic"
@@ -9,8 +9,8 @@ class APIProvider(StrEnum):
     VERTEX = "vertex"
 
 
-PROVIDER_TO_DEFAULT_MODEL_NAME: dict[APIProvider, str] = {
-    APIProvider.ANTHROPIC: "claude-3-7-sonnet-20250219",
-    APIProvider.BEDROCK: "anthropic.claude-3-7-sonnet-20250219-v2:0",
-    APIProvider.VERTEX: "claude-3-5-sonnet-v2@20241022",
+PROVIDER_TO_DEFAULT_MODEL_NAME: dict[LLMProvider, str] = {
+    LLMProvider.ANTHROPIC: "claude-3-7-sonnet-20250219",
+    LLMProvider.BEDROCK: "anthropic.claude-3-7-sonnet-20250219-v2:0",
+    LLMProvider.VERTEX: "claude-3-5-sonnet-v2@20241022",
 }

agent/providers/omni/__init__.py

@@ -2,7 +2,7 @@
 
 # The OmniComputerAgent has been replaced by the unified ComputerAgent
 # which can be found in agent.core.agent
-from .types import APIProvider
+from .types import LLMProvider
 from .experiment import ExperimentManager
 from .visualization import visualize_click, visualize_scroll, calculate_element_center
 from .image_utils import (
@@ -14,7 +14,7 @@ from .image_utils import (
 )
 
 __all__ = [
-    "APIProvider",
+    "LLMProvider",
     "ExperimentManager",
     "visualize_click",
     "visualize_scroll",

agent/providers/omni/loop.py

@@ -17,7 +17,7 @@ import copy
 from .parser import OmniParser, ParseResult, ParserMetadata, UIElement
 from ...core.loop import BaseLoop
 from computer import Computer
-from .types import APIProvider
+from .types import LLMProvider
 from .clients.base import BaseOmniClient
 from .clients.openai import OpenAIClient
 from .clients.groq import GroqClient
@@ -46,7 +46,7 @@ class OmniLoop(BaseLoop):
     def __init__(
         self,
         parser: OmniParser,
-        provider: APIProvider,
+        provider: LLMProvider,
         api_key: str,
         model: str,
         computer: Computer,
@@ -180,11 +180,11 @@ class OmniLoop(BaseLoop):
         try:
             logger.info(f"Initializing {self.provider} client with model {self.model}...")
 
-            if self.provider == APIProvider.OPENAI:
+            if self.provider == LLMProvider.OPENAI:
                 self.client = OpenAIClient(api_key=self.api_key, model=self.model)
-            elif self.provider == APIProvider.GROQ:
+            elif self.provider == LLMProvider.GROQ:
                 self.client = GroqClient(api_key=self.api_key, model=self.model)
-            elif self.provider == APIProvider.ANTHROPIC:
+            elif self.provider == LLMProvider.ANTHROPIC:
                 self.client = AnthropicClient(
                     api_key=self.api_key,
                     model=self.model,
@@ -228,7 +228,7 @@ class OmniLoop(BaseLoop):
                 prepared_messages = self.message_manager.get_formatted_messages(provider_name)
 
                 # Filter out system messages for Anthropic
-                if self.provider == APIProvider.ANTHROPIC:
+                if self.provider == LLMProvider.ANTHROPIC:
                     filtered_messages = [
                         msg for msg in prepared_messages if msg["role"] != "system"
                     ]
@@ -238,7 +238,7 @@ class OmniLoop(BaseLoop):
                 # Log request
                 request_data = {"messages": filtered_messages, "max_tokens": self.max_tokens}
 
-                if self.provider == APIProvider.ANTHROPIC:
+                if self.provider == LLMProvider.ANTHROPIC:
                     request_data["system"] = self._get_system_prompt()
                 else:
                     request_data["system"] = system_prompt
@@ -255,7 +255,7 @@ class OmniLoop(BaseLoop):
 
                 if is_async:
                     # For async implementations (AnthropicClient)
-                    if self.provider == APIProvider.ANTHROPIC:
+                    if self.provider == LLMProvider.ANTHROPIC:
                         response = await run_method(
                             messages=filtered_messages,
                             system=self._get_system_prompt(),
@@ -269,7 +269,7 @@ class OmniLoop(BaseLoop):
                         )
                 else:
                     # For non-async implementations (GroqClient, etc.)
-                    if self.provider == APIProvider.ANTHROPIC:
+                    if self.provider == LLMProvider.ANTHROPIC:
                         response = run_method(
                             messages=filtered_messages,
                             system=self._get_system_prompt(),
@@ -339,7 +339,7 @@ class OmniLoop(BaseLoop):
         action_screenshot_saved = False
         try:
             # Handle Anthropic response format
-            if self.provider == APIProvider.ANTHROPIC:
+            if self.provider == LLMProvider.ANTHROPIC:
                 if hasattr(response, "content") and isinstance(response.content, list):
                     # Extract text from content blocks
                     for block in response.content:
@@ -563,7 +563,7 @@ class OmniLoop(BaseLoop):
         """Process and add screen info to messages."""
         try:
             # Only add message if we have an image and provider supports it
-            if self.provider in [APIProvider.OPENAI, APIProvider.ANTHROPIC]:
+            if self.provider in [LLMProvider.OPENAI, LLMProvider.ANTHROPIC]:
                 image = parsed_screen.annotated_image_base64 or None
                 if image:
                     # Save screen info to current turn directory
@@ -577,7 +577,7 @@ class OmniLoop(BaseLoop):
                             logger.info(f"Saved elements to {elements_path}")
 
                     # Format the image content based on the provider
-                    if self.provider == APIProvider.ANTHROPIC:
+                    if self.provider == LLMProvider.ANTHROPIC:
                         # Compress the image before sending to Anthropic (5MB limit)
                         image_size = len(image)
                         logger.info(f"Image base64 is present, length: {image_size}")
@@ -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}")

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)}")

agent/providers/omni/prompts.py

@@ -62,17 +62,3 @@ IMPORTANT NOTES:
 9. Reflect whether the element is clickable or not, for example reflect if it is an hyperlink or a button or a normal text.
 10. If you are prompted with login information page or captcha page, or you think it need user's permission to do the next action, you should say "Action": "None" in the json field.
 """
-
-# SYSTEM_PROMPT1 = """You are an AI assistant helping users interact with their computer.
-# Analyze the screen information and respond with JSON containing:
-# {
-#     "Box ID": "Numeric ID of the relevant UI element",
-#     "Action": "One of: left_click, right_click, double_click, move_cursor, drag_to, type_text, press_key, hotkey, scroll_down, scroll_up, wait",
-#     "Value": "Text to type, key to press",
-#     "Explanation": "Why this action was chosen"
-# }
-
-# Notes:
-# - For starting applications, use the "hotkey" action with command+space for starting a Spotlight search.
-# - Each UI element is highlighted with a colored bounding box, and its Box ID appears nearby in the same color for easy identification.
-# """

agent/providers/omni/types.py

@@ -10,21 +10,18 @@ class LLMProvider(StrEnum):
 
     ANTHROPIC = "anthropic"
     OPENAI = "openai"
-    GROQ = "groq"
-    QWEN = "qwen"
 
 
-# For backward compatibility
-APIProvider = LLMProvider
+LLMProvider
 
 
 @dataclass
 class LLM:
     """Configuration for LLM model and provider."""
-    
+
     provider: LLMProvider
     name: Optional[str] = None
-    
+
     def __post_init__(self):
         """Set default model name if not provided."""
         if self.name is None:
@@ -40,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",
 }

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(),
+}

agent/types/base.py

@@ -44,9 +44,10 @@ class Annotation(BaseModel):
     vm_url: str
 
 
-class AgenticLoop(Enum):
+class AgentLoop(Enum):
     """Enumeration of available loop types."""
 
     ANTHROPIC = auto()  # Anthropic implementation
+    OPENAI = auto()  # OpenAI implementation
     OMNI = auto()  # OmniLoop implementation
     # Add more loop types as needed

{cua_agent-0.1.1.dist-info → cua_agent-0.1.3.dist-info}/METADATA

@@ -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.dist-info → cua_agent-0.1.3.dist-info}/RECORD

@@ -1,15 +1,16 @@
 agent/README.md,sha256=8EFnLrKejthEcL9bZflQSbvA-KwpiPanBz8TEEwRub8,2153
-agent/__init__.py,sha256=5IxjivBoXkpBQyPP3uwCrCoMx7gNZbM1rdVaIn2jxZ4,425
-agent/core/README.md,sha256=RY4kKEjm_-_Ul2xgY7ntzsXdPe0Tg1wvtOSZ4xp4DN0,3559
+agent/__init__.py,sha256=iX9e3iSpdUtqZAK9smiqwo3OcipR2v5rlXQyDiXXVxQ,691
+agent/core/README.md,sha256=VOXNVbR0ugxf9gCXYmZtUU2kngZhfi29haT_oSxK0Lk,3559
 agent/core/__init__.py,sha256=0htZ-VfsH9ixHB8j_SXu_uv6r3XXsq5TrghFNd-yRNE,709
-agent/core/agent.py,sha256=HSVNTiEhlDHMGJiA4CKi33TtwEdsMIvkgZ9nHfk2M8E,13730
-agent/core/base_agent.py,sha256=MgaMKTwgqNJ1-TgS_mxALoC9COzc7Acg9y7Q8HAFX2c,6266
+agent/core/agent.py,sha256=MN_A5gVS_E_1e9UFdRR8iKeR2xMfbbIL-9xK6w7GNwo,9703
+agent/core/base_agent.py,sha256=te9rk2tJZpEhDUEB1xSaFqe1zeOjmzMdHF5LaUDP2K0,6276
 agent/core/callbacks.py,sha256=VbGIf5QkHh3Q0KsLM6wv7hRdIA5WExTVYLm64bckyUA,4306
 agent/core/computer_agent.py,sha256=JGLMl_PwImUttmQh2amdLlXHS9CUyZ9MW20J1Xid7dM,2417
-agent/core/experiment.py,sha256=AST1t83eqaGzjoW6KvrhfVIs3ELAR_I70VHq2NsMmNk,7446
+agent/core/experiment.py,sha256=FKmSDyA2YFSrO3q-91ZT29Jm1lm24YCuK59wQ6z-6IM,7930
 agent/core/factory.py,sha256=WraOEHWPXBSN4R3DO7M2ctyadodeA8tzHM3dUjdQ_3A,3441
-agent/core/loop.py,sha256=E-0pz7MaguZQrHs5GP98Oc8C_Iz8ier0vXrD9Ny2HL8,8999
+agent/core/loop.py,sha256=vhdlSy_hIY3-a92uTGdF3oYE5Qcq0U2hyTJNmXunnfc,9009
 agent/core/messages.py,sha256=N8pV8Eh-AJpMuDPRI5OGWUIOU6DRr-pQjK9XU0go9Hk,7637
+agent/core/telemetry.py,sha256=bOP3z74dpXwvn1bGCVxe67jwu1m-4nYmKlypAJovqCQ,4304
 agent/core/tools/__init__.py,sha256=xZen-PqUp2dUaMEHJowXCQm33_5Sxhsx9PSoD0rq6tI,489
 agent/core/tools/base.py,sha256=CdzRFNuOjNfzgyTUN4ZoCGkUDR5HI0ECQVpvrUdEij8,2295
 agent/core/tools/bash.py,sha256=jnJKVlHn8np8e0gWd8EO0_qqjMkfQzutSugA_Iol4jE,1585
@@ -18,11 +19,11 @@ agent/core/tools/computer.py,sha256=lT_aW3huoYpcM8kffuokELupSz_WZG_qkaW1gITRC58,
 agent/core/tools/edit.py,sha256=kv4jTKCM0VXrnoNErf7mT-xlr81-7T8v49_VA9y_L4Y,2005
 agent/core/tools/manager.py,sha256=IRsCXjGc076nncQuyIjODoafnHTDhrf9sP5B4q5Pcdo,1742
 agent/providers/__init__.py,sha256=b4tIBAaIB1V7p8V0BWipHVnMhfHH_OuVgP4OWGSHdD8,194
-agent/providers/anthropic/__init__.py,sha256=vEqLDkYXZoXg9A64bOtWfv9hoJlJCXbTpQGcmQ9eec8,149
-agent/providers/anthropic/api/client.py,sha256=_DeCn6bYgVG0LcQYDO6VCjTPrt6U-PO5vr4GWmhCPH8,7404
+agent/providers/anthropic/__init__.py,sha256=Mj11IZnVshZ2iHkvg4Z5-jrQIaD1WvzDz2Zk_pMwqIA,149
+agent/providers/anthropic/api/client.py,sha256=Y_g4Xg8Ko4tCqjipVm0GBMw-86vw0KQVXS5aWzJinzw,7038
 agent/providers/anthropic/api/logging.py,sha256=vHpwkIyOZdkSTVIH4ycbBPd4a_rzhP7Osu1I-Ayouwc,5154
 agent/providers/anthropic/callbacks/manager.py,sha256=dRKN7MuBze2dLal0iHDxCKYqMdh_KShSphuwn7zC-c4,1878
-agent/providers/anthropic/loop.py,sha256=GfUU_0erZgaM8oENSbrKEepsYsYTfuOiygcjHK0pefY,17904
+agent/providers/anthropic/loop.py,sha256=-g-OUpdVPSTO5kFJSZ5AmnjoWSEs2niHZFSR6B_KKvU,17904
 agent/providers/anthropic/messages/manager.py,sha256=atD41v6bjC1STxRB-jLBty9wHlMwacH9cwsL4tBz3uo,4891
 agent/providers/anthropic/prompts.py,sha256=nHFfgPrfvnWrEdVP7EUBGUHAI85D2X9HeZirk9EwncU,1941
 agent/providers/anthropic/tools/__init__.py,sha256=JyZwuVtPUnZwRSZBSCdQv9yxbLCsygm3l8Ywjjt9qTQ,661
@@ -33,8 +34,8 @@ agent/providers/anthropic/tools/computer.py,sha256=WnQS2rIIDz1juwoQMun2ODJjOV134
 agent/providers/anthropic/tools/edit.py,sha256=EGRP61MDA4Oue1D7Q-_vLpd6LdGbdBA1Z4HSZ66DbmI,13465
 agent/providers/anthropic/tools/manager.py,sha256=zW-biqO_MV3fb1nDEOl3EmCXD1leoglFj6LDRSM3djs,1982
 agent/providers/anthropic/tools/run.py,sha256=xhXdnBK1di9muaO44CEirL9hpGy3NmKbjfMpyeVmn8Y,1595
-agent/providers/anthropic/types.py,sha256=kKc4XvSuKfumv4KLpJOwyY4t5deBsLgZTSAP4raZGvg,421
-agent/providers/omni/__init__.py,sha256=wKOVVWHkD-p4QUz0TIEENkMb7Iq2LRSh88KUGBW1XQA,744
+agent/providers/anthropic/types.py,sha256=SF00kOMC1ui8j9Ah56KaeiR2cL394qCHjFIsBpXxt5w,421
+agent/providers/omni/__init__.py,sha256=eTUh4Pmh4zO-RLnP-wAFm8EkJBMImT-G2xnVIYWRti0,744
 agent/providers/omni/callbacks.py,sha256=ZG9NCgsHWt6y5jKsfcGLaoLxTpmKnIhCArDdeP4q9sA,2369
 agent/providers/omni/clients/anthropic.py,sha256=X_QRVxqwA_ExdUqgBEwo1aHOfZQxVIBDmDugNHF97OM,3554
 agent/providers/omni/clients/base.py,sha256=zAAgPi0jl3SWPC730R9l79E8bfYPSo39UtCSE-mrK6I,1076
@@ -43,23 +44,24 @@ agent/providers/omni/clients/openai.py,sha256=E4TAXMUFoYTunJETCWCNx5XAc6xutiN4rB
 agent/providers/omni/clients/utils.py,sha256=Ani9CVVBm_J2Dl51WG6p1GVuoI6cq8scISrG0pmQ37o,688
 agent/providers/omni/experiment.py,sha256=JGAdHi7Nf73I48c9k3TY1Xpr_i6D2VG1wurOzw5cNGk,9888
 agent/providers/omni/image_utils.py,sha256=qIFuNi5cIMVwrqYBXG1T6PxUlbxz7gIngFFP39bZIlU,2782
-agent/providers/omni/loop.py,sha256=U1R_ayfN4T25hvbLMp97qeqSrqVtSL-U03G8Sqf4AaM,43827
+agent/providers/omni/loop.py,sha256=72o7q92nO7i0EUrVhEPCEHprRKdBYsg5iLTLfLHXAsw,43847
 agent/providers/omni/messages.py,sha256=zdjQCAMH-hOyrQQesHhTiIsQbw43KqVSmVIzS8JOIFA,6134
-agent/providers/omni/parser.py,sha256=Iv-cXWG2qzdYjyZJH5pGUzfv6nOaiHQ2OXdQSe00Ydw,9151
-agent/providers/omni/prompts.py,sha256=29qy8ppbLOjLil3aiqryjaiBf8CQx-xXHN44O-85Q00,4503
+agent/providers/omni/parser.py,sha256=lTAoSMSf2zpwqR_8W0SXG3cYIFeUiZa5vXdpjqZwEHY,9161
+agent/providers/omni/prompts.py,sha256=Mupjy0bUwBjcAeLXpE1r1jisYPSlhwsp-IXJKEKrEtw,3779
 agent/providers/omni/tool_manager.py,sha256=O6DxyEI-Vg6jt99phh011o4q4me_vNhH2YffIxkO4GM,2585
 agent/providers/omni/tools/__init__.py,sha256=l636hx9Q5z9eaFdPanPwPENUE-w-Xm8kAZhPUq0ZQF4,309
 agent/providers/omni/tools/bash.py,sha256=y_ibfP9iRcbiU_E0faAoa4DCP_BlkMlKOOURdBBIGZE,2030
 agent/providers/omni/tools/computer.py,sha256=xkMmAR0e_kbf0Zs2mggCDyWrQOJZyXOKPFjkutaQb94,9108
 agent/providers/omni/tools/manager.py,sha256=V_tav2yU92PyQnFlxNXG1wvNEaJoEYudtKx5sRjj06Q,2619
-agent/providers/omni/types.py,sha256=6x-n3MLvvKOFAdvzYDf6Zzw-i118kvWHXE37qxa_L4o,1284
+agent/providers/omni/types.py,sha256=rpr7-mH9VK1R-nJ6tVu1gKp427j-hw1DpHc197b44nU,1017
 agent/providers/omni/utils.py,sha256=JqSye1bEp4wxhUgmaMyZi172fTlgXtygJ7XlnvKdUtE,6337
 agent/providers/omni/visualization.py,sha256=N3qVQLxYmia3iSVC5oCt5YRlMPuVfylCOyB99R33u8U,3924
+agent/telemetry.py,sha256=pVGxbj0ewnvq4EGj28CydN4a1iOfvZR_XKL3vIOqhOM,390
 agent/types/__init__.py,sha256=61UFJT-w0CT4YRn0LiTx4A7fsMdVQjlXO9vnmbI1A7Y,604
-agent/types/base.py,sha256=rVb4mPWp1SOHfrzOCDqx0pfCV5bgIsdrIzgM_kX_xVs,1090
+agent/types/base.py,sha256=Iy_Q2DIBMLtwWdLyfvHw_6E2ltYu3bIv8GUNy3LYkGs,1133
 agent/types/messages.py,sha256=4-hwtxeAhto90_EZpHFducddtsHUsHauvXzYrpKG4RE,953
 agent/types/tools.py,sha256=Jes2CFCFqC727WWHbO-sG7V03rBHnQe5X7Oi9ZkuScI,877
-cua_agent-0.1.1.dist-info/METADATA,sha256=JdbHHQ7uBAlcnLZpZ1eWCiPCDODEOaB50j6XwtIs0Ss,1890
-cua_agent-0.1.1.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
-cua_agent-0.1.1.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
-cua_agent-0.1.1.dist-info/RECORD,,
+cua_agent-0.1.3.dist-info/METADATA,sha256=jrj3DGxV6UHOSezXqLY2BhjmZxI1Eunv9aFXcoUQmgs,1928
+cua_agent-0.1.3.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
+cua_agent-0.1.3.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+cua_agent-0.1.3.dist-info/RECORD,,