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

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

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, 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:
@@ -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",
 }
 
@@ -55,79 +57,68 @@ 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: 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
+            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
+
+        # 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)
+        # Initialize message history
+        self.messages = []
 
-        # 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
+        # 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: AgentLoop
     ) -> LLM:
@@ -200,7 +191,7 @@ class ComputerAgent(BaseComputerAgent):
             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,
@@ -209,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 == 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"},
-                }
+            # 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/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}")

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/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",
 }

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

@@ -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.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=BRIunVPG0T5CdAiNJyElKxUZN8Mngg2_TmtLwaupG4I,355
+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=AQ-S2wVD82RFnD_HmR-zjA7Jj09CUKGp7KreWX1j6Fg,13495
-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
@@ -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=mHCs13in3mrLizF1x8OeCXECp4bL9-CYS_XOJOUZqu8,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/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=G7Zqm-nWMa3K2klj-D3KUVWc2r8NJB7sYZCwwl0m9Ic,1233
+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=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.2.dist-info/METADATA,sha256=bXSToJpS_e5KRzyRELUzCuOkozsDUD29pBMj3DKzF7U,1890
-cua_agent-0.1.2.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
-cua_agent-0.1.2.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
-cua_agent-0.1.2.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,,