cua-agent 0.1.5__py3-none-any.whl → 0.1.6__py3-none-any.whl

{cua_agent-0.1.5.dist-info → cua_agent-0.1.6.dist-info}/RECORD

@@ -1,16 +1,13 @@
 agent/README.md,sha256=8EFnLrKejthEcL9bZflQSbvA-KwpiPanBz8TEEwRub8,2153
-agent/__init__.py,sha256=sxUp_I8cI4NVa2DY8g-tsJe5_XJJe5VdeS_VLgA98EM,1569
+agent/__init__.py,sha256=Pil-INEbTU7iOlZXP3QN-kV_IHtW9uk7PuJCON319Ws,1437
 agent/core/README.md,sha256=VOXNVbR0ugxf9gCXYmZtUU2kngZhfi29haT_oSxK0Lk,3559
-agent/core/__init__.py,sha256=0htZ-VfsH9ixHB8j_SXu_uv6r3XXsq5TrghFNd-yRNE,709
-agent/core/agent.py,sha256=A07a7mRtKqpX2AHCP1i8KesOqoOETfh23CyTTQth6vI,9327
-agent/core/base_agent.py,sha256=te9rk2tJZpEhDUEB1xSaFqe1zeOjmzMdHF5LaUDP2K0,6276
+agent/core/__init__.py,sha256=bds3kSkCILroIxxqU4scCPPCr-pooIkF2S4oU3OgsGY,638
 agent/core/callbacks.py,sha256=VbGIf5QkHh3Q0KsLM6wv7hRdIA5WExTVYLm64bckyUA,4306
-agent/core/computer_agent.py,sha256=JGLMl_PwImUttmQh2amdLlXHS9CUyZ9MW20J1Xid7dM,2417
-agent/core/experiment.py,sha256=FKmSDyA2YFSrO3q-91ZT29Jm1lm24YCuK59wQ6z-6IM,7930
-agent/core/factory.py,sha256=WraOEHWPXBSN4R3DO7M2ctyadodeA8tzHM3dUjdQ_3A,3441
-agent/core/loop.py,sha256=vhdlSy_hIY3-a92uTGdF3oYE5Qcq0U2hyTJNmXunnfc,9009
+agent/core/computer_agent.py,sha256=7JOwAEeB1CL8Sw_1WAE3_a9tswZyCaBdXWDCfD3r7M4,9976
+agent/core/experiment.py,sha256=Ywj6q3JZFDKicfPuQsDl0vSN55HS7-Cnk3u3EcUCKe8,8866
+agent/core/loop.py,sha256=j4zI7h6mifQ5kMn9y0NcjAi1ZpvSBHoPL7Lk2e1OGsQ,9255
 agent/core/messages.py,sha256=N8pV8Eh-AJpMuDPRI5OGWUIOU6DRr-pQjK9XU0go9Hk,7637
-agent/core/telemetry.py,sha256=cCnITdDxOSHM0qKV7Fe5sV2gD6B_InRxMVFm-EgKF7M,4083
+agent/core/telemetry.py,sha256=HElPd32k_w2SJ6t-Cc3j_2-AKdLbFwh2YlM8QViDgRw,4790
 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
@@ -23,16 +20,16 @@ agent/providers/anthropic/__init__.py,sha256=Mj11IZnVshZ2iHkvg4Z5-jrQIaD1WvzDz2Z
 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=-g-OUpdVPSTO5kFJSZ5AmnjoWSEs2niHZFSR6B_KKvU,17904
-agent/providers/anthropic/messages/manager.py,sha256=atD41v6bjC1STxRB-jLBty9wHlMwacH9cwsL4tBz3uo,4891
+agent/providers/anthropic/loop.py,sha256=uPjgXoGRdJb5bsJchUh_0aUuyRBm-HSp7jaM2cKg61I,19466
+agent/providers/anthropic/messages/manager.py,sha256=6FobzAHh5-7dxaxbUdG1--1UY4w-mh3MFytX6ONrK3c,4972
 agent/providers/anthropic/prompts.py,sha256=nHFfgPrfvnWrEdVP7EUBGUHAI85D2X9HeZirk9EwncU,1941
 agent/providers/anthropic/tools/__init__.py,sha256=JyZwuVtPUnZwRSZBSCdQv9yxbLCsygm3l8Ywjjt9qTQ,661
-agent/providers/anthropic/tools/base.py,sha256=B1oKv9syFv_JNuCybpllf1PxO8D7ZVtt6C-uoP-GYgw,2799
+agent/providers/anthropic/tools/base.py,sha256=WnRDbqO25tQzLpS2RU2ZXTLF5wd5IqU7SiyRAglQat4,2752
 agent/providers/anthropic/tools/bash.py,sha256=CIh4pO0jEdSZApnjpmFhrQbTTiwxivuOgv1-QLN0Ydw,5740
-agent/providers/anthropic/tools/collection.py,sha256=8RzHLobL44_Jjt8ltXS6I8XJlEAQOfc75dmnDUaHE-8,922
-agent/providers/anthropic/tools/computer.py,sha256=WnQS2rIIDz1juwoQMun2ODJjOV134tiZRKOyFzLmshk,24900
+agent/providers/anthropic/tools/collection.py,sha256=RBK_6hxfHExR-EOxadiLl0OznmFj07nyIUjFgaYZ6Eo,960
+agent/providers/anthropic/tools/computer.py,sha256=vYni1jDOOgzSSBOJxHcEKxvKUYRp5_nQ-9dmpGdLwm4,25858
 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/manager.py,sha256=yNvgTkfEqnOz5isDF0RxvmBMZB0uh2PipFEH-PUXpoY,2020
 agent/providers/anthropic/tools/run.py,sha256=xhXdnBK1di9muaO44CEirL9hpGy3NmKbjfMpyeVmn8Y,1595
 agent/providers/anthropic/types.py,sha256=SF00kOMC1ui8j9Ah56KaeiR2cL394qCHjFIsBpXxt5w,421
 agent/providers/omni/__init__.py,sha256=eTUh4Pmh4zO-RLnP-wAFm8EkJBMImT-G2xnVIYWRti0,744
@@ -42,26 +39,26 @@ agent/providers/omni/clients/base.py,sha256=zAAgPi0jl3SWPC730R9l79E8bfYPSo39UtCS
 agent/providers/omni/clients/groq.py,sha256=HEinpE0_Cp_-geMyjJ8qaTPl0regPtETPkem4U13qG4,3599
 agent/providers/omni/clients/openai.py,sha256=E4TAXMUFoYTunJETCWCNx5XAc6xutiN4rB6PlVpzC5s,5972
 agent/providers/omni/clients/utils.py,sha256=Ani9CVVBm_J2Dl51WG6p1GVuoI6cq8scISrG0pmQ37o,688
-agent/providers/omni/experiment.py,sha256=JGAdHi7Nf73I48c9k3TY1Xpr_i6D2VG1wurOzw5cNGk,9888
+agent/providers/omni/experiment.py,sha256=ZZ45U5NEkpzMNeMO9hJfpRf3iPNFaSZVwChcfqOgbI0,10002
 agent/providers/omni/image_utils.py,sha256=qIFuNi5cIMVwrqYBXG1T6PxUlbxz7gIngFFP39bZIlU,2782
-agent/providers/omni/loop.py,sha256=72o7q92nO7i0EUrVhEPCEHprRKdBYsg5iLTLfLHXAsw,43847
+agent/providers/omni/loop.py,sha256=10GxyZFG8wAYObaaInWSZDRVwWNnZk_qhqdGr3PIPe0,44022
 agent/providers/omni/messages.py,sha256=zdjQCAMH-hOyrQQesHhTiIsQbw43KqVSmVIzS8JOIFA,6134
-agent/providers/omni/parser.py,sha256=lTAoSMSf2zpwqR_8W0SXG3cYIFeUiZa5vXdpjqZwEHY,9161
+agent/providers/omni/parser.py,sha256=4n1rzaD-mHi7sMfeqChgOyrJuciwzL95x32BGI6GATM,9194
 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/__init__.py,sha256=RkxsPTow3jpOKuXJ1ZKb-KBi6lbxGWfjC9gaV6hSZIs,278
 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/tools/computer.py,sha256=s8WVA_xGROEfdmCYjEqr563ySp4DRMlsLVuu54nH0Ww,9129
+agent/providers/omni/tools/manager.py,sha256=EyNABQeJc8bEcJ4hFsRodKyBNkZpThfOHk1Ku3Pzsg8,2519
 agent/providers/omni/types.py,sha256=rpr7-mH9VK1R-nJ6tVu1gKp427j-hw1DpHc197b44nU,1017
-agent/providers/omni/utils.py,sha256=JqSye1bEp4wxhUgmaMyZi172fTlgXtygJ7XlnvKdUtE,6337
+agent/providers/omni/utils.py,sha256=X2IBki6yJQFaEz7PDjkx8CqQq2R1v7nldRcOT5j7YcA,6381
 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/__init__.py,sha256=Xi6nNSsfbsGxs3We8gbdEY0ew0Jf0A0Prs5393Tvveg,568
+agent/types/base.py,sha256=_5LNleRTqoL55VHEEZntL8x-OQom2A3FiTf2ttdM_HQ,857
 agent/types/messages.py,sha256=4-hwtxeAhto90_EZpHFducddtsHUsHauvXzYrpKG4RE,953
 agent/types/tools.py,sha256=Jes2CFCFqC727WWHbO-sG7V03rBHnQe5X7Oi9ZkuScI,877
-cua_agent-0.1.5.dist-info/METADATA,sha256=yyoO57p8w39kdnzJY1bT6YelaaZRxzokxQUNMFyJQZY,4528
-cua_agent-0.1.5.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
-cua_agent-0.1.5.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
-cua_agent-0.1.5.dist-info/RECORD,,
+cua_agent-0.1.6.dist-info/METADATA,sha256=rD_j8q7aC5wkNQtpbgRLyo3-5z_zCDivJE8MwyPpz6I,4528
+cua_agent-0.1.6.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
+cua_agent-0.1.6.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+cua_agent-0.1.6.dist-info/RECORD,,

agent/core/agent.py

@@ -1,252 +0,0 @@
-"""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
-
-        # 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

agent/core/base_agent.py

@@ -1,164 +0,0 @@
-"""Base computer agent implementation."""
-
-import asyncio
-import logging
-import os
-from abc import ABC, abstractmethod
-from typing import Any, AsyncGenerator, Dict, Optional
-
-from computer import Computer
-
-from ..types.base import Provider
-
-logger = logging.getLogger(__name__)
-
-
-class BaseComputerAgent(ABC):
-    """Base class for computer agents."""
-
-    def __init__(
-        self,
-        max_retries: int = 3,
-        computer: Optional[Computer] = None,
-        screenshot_dir: Optional[str] = None,
-        log_dir: Optional[str] = None,
-        **kwargs,
-    ):
-        """Initialize the base computer agent.
-
-        Args:
-            max_retries: Maximum number of retry attempts
-            computer: Optional Computer instance
-            screenshot_dir: Directory to save screenshots
-            log_dir: Directory to save logs (set to None to disable logging to files)
-            **kwargs: Additional provider-specific arguments
-        """
-        self.max_retries = max_retries
-        self.computer = computer or Computer()
-        self.queue = asyncio.Queue()
-        self.screenshot_dir = screenshot_dir
-        self.log_dir = log_dir
-        self._retry_count = 0
-        self.provider = Provider.UNKNOWN
-
-        # Setup logging
-        if self.log_dir:
-            os.makedirs(self.log_dir, exist_ok=True)
-            logger.info(f"Created logs directory: {self.log_dir}")
-
-        # Setup screenshots directory
-        if self.screenshot_dir:
-            os.makedirs(self.screenshot_dir, exist_ok=True)
-            logger.info(f"Created screenshots directory: {self.screenshot_dir}")
-
-        logger.info("BaseComputerAgent initialized")
-
-    async def run(self, task: str) -> AsyncGenerator[Dict[str, Any], None]:
-        """Run a task using the computer agent.
-
-        Args:
-            task: Task description
-
-        Yields:
-            Task execution updates
-        """
-        try:
-            logger.info(f"Running task: {task}")
-
-            # Initialize the computer if needed
-            await self._init_if_needed()
-
-            # Execute the task and yield results
-            # The _execute_task method should be implemented to yield results
-            async for result in self._execute_task(task):
-                yield result
-
-        except Exception as e:
-            logger.error(f"Error in agent run method: {str(e)}")
-            yield {
-                "role": "assistant",
-                "content": f"Error: {str(e)}",
-                "metadata": {"title": "❌ Error"},
-            }
-
-    async def _init_if_needed(self):
-        """Initialize the computer interface if it hasn't been initialized yet."""
-        if not self.computer._initialized:
-            logger.info("Computer not initialized, initializing now...")
-            try:
-                # Call run directly without setting the flag first
-                await self.computer.run()
-                logger.info("Computer interface initialized successfully")
-            except Exception as e:
-                logger.error(f"Error initializing computer interface: {str(e)}")
-                raise
-
-    async def __aenter__(self):
-        """Initialize the agent when used as a context manager."""
-        logger.info("Entering BaseComputerAgent context")
-
-        # In case the computer wasn't initialized
-        try:
-            # Initialize the computer only if not already initialized
-            logger.info("Checking if computer is already initialized...")
-            if not self.computer._initialized:
-                logger.info("Initializing computer in __aenter__...")
-                # Use the computer's __aenter__ directly instead of calling run()
-                # This avoids the circular dependency
-                await self.computer.__aenter__()
-                logger.info("Computer initialized in __aenter__")
-            else:
-                logger.info("Computer already initialized, skipping initialization")
-
-            # Take a test screenshot to verify the computer is working
-            logger.info("Testing computer with a screenshot...")
-            try:
-                test_screenshot = await self.computer.interface.screenshot()
-                # Determine the screenshot size based on its type
-                if isinstance(test_screenshot, bytes):
-                    size = len(test_screenshot)
-                else:
-                    # Assume it's an object with base64_image attribute
-                    try:
-                        size = len(test_screenshot.base64_image)
-                    except AttributeError:
-                        size = "unknown"
-                logger.info(f"Screenshot test successful, size: {size}")
-            except Exception as e:
-                logger.error(f"Screenshot test failed: {str(e)}")
-                # Even though screenshot failed, we continue since some tests might not need it
-        except Exception as e:
-            logger.error(f"Error initializing computer in __aenter__: {str(e)}")
-            raise
-
-        return self
-
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        """Cleanup computer resources if needed."""
-        logger.info("Cleaning up agent resources")
-
-        # Do any necessary cleanup
-        # We're not shutting down the computer here as it might be shared
-        # Just log that we're exiting
-        if exc_type:
-            logger.error(f"Exiting agent context with error: {exc_type.__name__}: {exc_val}")
-        else:
-            logger.info("Exiting agent context normally")
-
-        # If we have a queue, make sure to signal it's done
-        if hasattr(self, "queue") and self.queue:
-            await self.queue.put(None)  # Signal that we're done
-
-    @abstractmethod
-    async def _execute_task(self, task: str) -> AsyncGenerator[Dict[str, Any], None]:
-        """Execute a task. Must be implemented by subclasses.
-
-        This is an async method that returns an AsyncGenerator. Implementations
-        should use 'yield' statements to produce results asynchronously.
-        """
-        yield {
-            "role": "assistant",
-            "content": "Base class method called",
-            "metadata": {"title": "Error"},
-        }
-        raise NotImplementedError("Subclasses must implement _execute_task")

agent/core/factory.py

@@ -1,102 +0,0 @@
-"""Factory for creating provider-specific agents."""
-
-from typing import Optional, Dict, Any, List
-
-from computer import Computer
-from ..types.base import Provider
-from .base_agent import BaseComputerAgent
-
-# Import provider-specific implementations
-_ANTHROPIC_AVAILABLE = False
-_OPENAI_AVAILABLE = False
-_OLLAMA_AVAILABLE = False
-_OMNI_AVAILABLE = False
-
-# Try importing providers
-try:
-    import anthropic
-    from ..providers.anthropic.agent import AnthropicComputerAgent
-
-    _ANTHROPIC_AVAILABLE = True
-except ImportError:
-    pass
-
-try:
-    import openai
-
-    _OPENAI_AVAILABLE = True
-except ImportError:
-    pass
-
-try:
-    from ..providers.omni.agent import OmniComputerAgent
-
-    _OMNI_AVAILABLE = True
-except ImportError:
-    pass
-
-
-class AgentFactory:
-    """Factory for creating provider-specific agent implementations."""
-
-    @staticmethod
-    def create(
-        provider: Provider, computer: Optional[Computer] = None, **kwargs: Any
-    ) -> BaseComputerAgent:
-        """Create an agent based on the specified provider.
-
-        Args:
-            provider: The AI provider to use
-            computer: Optional Computer instance
-            **kwargs: Additional provider-specific arguments
-
-        Returns:
-            A provider-specific agent implementation
-
-        Raises:
-            ImportError: If provider dependencies are not installed
-            ValueError: If provider is not supported
-        """
-        # Create a Computer instance if none is provided
-        if computer is None:
-            computer = Computer()
-
-        if provider == Provider.ANTHROPIC:
-            if not _ANTHROPIC_AVAILABLE:
-                raise ImportError(
-                    "Anthropic provider requires additional dependencies. "
-                    "Install them with: pip install cua-agent[anthropic]"
-                )
-            return AnthropicComputerAgent(max_retries=3, computer=computer, **kwargs)
-        elif provider == Provider.OPENAI:
-            if not _OPENAI_AVAILABLE:
-                raise ImportError(
-                    "OpenAI provider requires additional dependencies. "
-                    "Install them with: pip install cua-agent[openai]"
-                )
-            raise NotImplementedError("OpenAI provider not yet implemented")
-        elif provider == Provider.OLLAMA:
-            if not _OLLAMA_AVAILABLE:
-                raise ImportError(
-                    "Ollama provider requires additional dependencies. "
-                    "Install them with: pip install cua-agent[ollama]"
-                )
-            # Only import ollama when actually creating an Ollama agent
-            try:
-                import ollama
-                from ..providers.ollama.agent import OllamaComputerAgent
-
-                return OllamaComputerAgent(max_retries=3, computer=computer, **kwargs)
-            except ImportError:
-                raise ImportError(
-                    "Failed to import ollama package. " "Install it with: pip install ollama"
-                )
-        elif provider == Provider.OMNI:
-            if not _OMNI_AVAILABLE:
-                raise ImportError(
-                    "Omni provider requires additional dependencies. "
-                    "Install them with: pip install cua-agent[omni]"
-                )
-            return OmniComputerAgent(max_retries=3, computer=computer, **kwargs)
-        else:
-            raise ValueError(f"Unsupported provider: {provider}")