cua-agent 0.3.2__py3-none-any.whl → 0.4.0b2__py3-none-any.whl

cua_agent-0.4.0b2.dist-info/METADATA

@@ -0,0 +1,424 @@
+Metadata-Version: 2.1
+Name: cua-agent
+Version: 0.4.0b2
+Summary: CUA (Computer Use) Agent for AI-driven computer interaction
+Author-Email: TryCua <gh@trycua.com>
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: aiohttp>=3.9.3
+Requires-Dist: asyncio
+Requires-Dist: anyio>=4.4.1
+Requires-Dist: typing-extensions>=4.12.2
+Requires-Dist: pydantic>=2.6.4
+Requires-Dist: rich>=13.7.1
+Requires-Dist: python-dotenv>=1.0.1
+Requires-Dist: cua-computer<0.5.0,>=0.3.0
+Requires-Dist: cua-core<0.2.0,>=0.1.0
+Requires-Dist: certifi>=2024.2.2
+Requires-Dist: litellm>=1.74.8
+Provides-Extra: openai
+Provides-Extra: anthropic
+Provides-Extra: omni
+Requires-Dist: ultralytics>=8.0.0; extra == "omni"
+Requires-Dist: cua-som<0.2.0,>=0.1.0; extra == "omni"
+Provides-Extra: uitars
+Provides-Extra: uitars-mlx
+Requires-Dist: mlx-vlm>=0.1.27; sys_platform == "darwin" and extra == "uitars-mlx"
+Provides-Extra: uitars-hf
+Requires-Dist: transformers>=4.54.0; extra == "uitars-hf"
+Provides-Extra: ui
+Requires-Dist: gradio>=5.23.3; extra == "ui"
+Requires-Dist: python-dotenv>=1.0.1; extra == "ui"
+Provides-Extra: cli
+Requires-Dist: yaspin>=3.1.0; extra == "cli"
+Provides-Extra: all
+Requires-Dist: ultralytics>=8.0.0; extra == "all"
+Requires-Dist: cua-som<0.2.0,>=0.1.0; extra == "all"
+Requires-Dist: mlx-vlm>=0.1.27; sys_platform == "darwin" and extra == "all"
+Requires-Dist: transformers>=4.54.0; extra == "all"
+Requires-Dist: gradio>=5.23.3; extra == "all"
+Requires-Dist: python-dotenv>=1.0.1; extra == "all"
+Requires-Dist: yaspin>=3.1.0; extra == "all"
+Description-Content-Type: text/markdown
+
+<div align="center">
+<h1>
+  <div class="image-wrapper" style="display: inline-block;">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" alt="logo" height="150" srcset="../../../img/logo_white.png" style="display: block; margin: auto;">
+      <source media="(prefers-color-scheme: light)" alt="logo" height="150" srcset="../../../img/logo_black.png" style="display: block; margin: auto;">
+      <img alt="Shows my svg">
+    </picture>
+  </div>
+
+  [![Python](https://img.shields.io/badge/Python-333333?logo=python&logoColor=white&labelColor=333333)](#)
+  [![macOS](https://img.shields.io/badge/macOS-000000?logo=apple&logoColor=F0F0F0)](#)
+  [![Discord](https://img.shields.io/badge/Discord-%235865F2.svg?&logo=discord&logoColor=white)](https://discord.com/invite/mVnXXpdE85)
+  [![PyPI](https://img.shields.io/pypi/v/cua-computer?color=333333)](https://pypi.org/project/cua-computer/)
+</h1>
+</div>
+
+**cua-agent** is a general Computer-Use framework with liteLLM integration for running agentic workflows on macOS, Windows, and Linux sandboxes. It provides a unified interface for computer-use agents across multiple LLM providers with advanced callback system for extensibility.
+
+## Features
+
+- **Safe Computer-Use/Tool-Use**: Using Computer SDK for sandboxed desktops
+- **Multi-Agent Support**: Anthropic Claude, OpenAI computer-use-preview, UI-TARS, Omniparser + any LLM
+- **Multi-API Support**: Take advantage of liteLLM supporting 100+ LLMs / model APIs, including local models (`huggingface-local/`, `ollama_chat/`, `mlx/`)
+- **Cross-Platform**: Works on Windows, macOS, and Linux with cloud and local computer instances
+- **Extensible Callbacks**: Built-in support for image retention, cache control, PII anonymization, budget limits, and trajectory tracking
+
+## Install
+
+```bash
+pip install "cua-agent[all]"
+
+# or install specific providers
+pip install "cua-agent[openai]"        # OpenAI computer-use-preview support
+pip install "cua-agent[anthropic]"     # Anthropic Claude support
+pip install "cua-agent[omni]"          # Omniparser + any LLM support
+pip install "cua-agent[uitars]"        # UI-TARS
+pip install "cua-agent[uitars-mlx]"    # UI-TARS + MLX support
+pip install "cua-agent[uitars-hf]"     # UI-TARS + Huggingface support
+pip install "cua-agent[ui]"            # Gradio UI support
+```
+
+## Quick Start
+
+```python
+import asyncio
+import os
+from agent import ComputerAgent
+from computer import Computer
+
+async def main():
+    # Set up computer instance
+    async with Computer(
+        os_type="linux",
+        provider_type="cloud",
+        name=os.getenv("CUA_CONTAINER_NAME"),
+        api_key=os.getenv("CUA_API_KEY")
+    ) as computer:
+        
+        # Create agent
+        agent = ComputerAgent(
+            model="anthropic/claude-3-5-sonnet-20241022",
+            tools=[computer],
+            only_n_most_recent_images=3,
+            trajectory_dir="trajectories",
+            max_trajectory_budget=5.0  # $5 budget limit
+        )
+        
+        # Run agent
+        messages = [{"role": "user", "content": "Take a screenshot and tell me what you see"}]
+        
+        async for result in agent.run(messages):
+            for item in result["output"]:
+                if item["type"] == "message":
+                    print(item["content"][0]["text"])
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Supported Models
+
+### Anthropic Claude (Computer Use API)
+```python
+model="anthropic/claude-3-5-sonnet-20241022"
+model="anthropic/claude-3-5-sonnet-20240620"
+model="anthropic/claude-opus-4-20250514"
+model="anthropic/claude-sonnet-4-20250514"
+```
+
+### OpenAI Computer Use Preview
+```python
+model="openai/computer-use-preview"
+```
+
+### UI-TARS (Local or Huggingface Inference)
+```python
+model="huggingface-local/ByteDance-Seed/UI-TARS-1.5-7B"
+model="ollama_chat/0000/ui-tars-1.5-7b"
+```
+
+### Omniparser + Any LLM
+```python
+model="omniparser+ollama_chat/mistral-small3.2"
+model="omniparser+vertex_ai/gemini-pro"
+model="omniparser+anthropic/claude-3-5-sonnet-20241022"
+model="omniparser+openai/gpt-4o"
+```
+
+## Custom Tools
+
+Define custom tools using decorated functions:
+
+```python
+from computer.helpers import sandboxed
+
+@sandboxed()
+def read_file(location: str) -> str:
+    """Read contents of a file
+    
+    Parameters
+    ----------
+    location : str
+        Path to the file to read
+        
+    Returns
+    -------
+    str
+        Contents of the file or error message
+    """
+    try:
+        with open(location, 'r') as f:
+            return f.read()
+    except Exception as e:
+        return f"Error reading file: {str(e)}"
+
+def calculate(a: int, b: int) -> int:
+    """Calculate the sum of two integers"""
+    return a + b
+
+# Use with agent
+agent = ComputerAgent(
+    model="anthropic/claude-3-5-sonnet-20241022",
+    tools=[computer, read_file, calculate]
+)
+```
+
+## Callbacks System
+
+agent provides a comprehensive callback system for extending functionality:
+
+### Built-in Callbacks
+
+```python
+from agent.callbacks import (
+    ImageRetentionCallback,
+    TrajectorySaverCallback, 
+    BudgetManagerCallback,
+    LoggingCallback
+)
+
+agent = ComputerAgent(
+    model="anthropic/claude-3-5-sonnet-20241022",
+    tools=[computer],
+    callbacks=[
+        ImageRetentionCallback(only_n_most_recent_images=3),
+        TrajectorySaverCallback(trajectory_dir="trajectories"),
+        BudgetManagerCallback(max_budget=10.0, raise_error=True),
+        LoggingCallback(level=logging.INFO)
+    ]
+)
+```
+
+### Custom Callbacks
+
+```python
+from agent.callbacks.base import AsyncCallbackHandler
+
+class CustomCallback(AsyncCallbackHandler):
+    async def on_llm_start(self, messages):
+        """Preprocess messages before LLM call"""
+        # Add custom preprocessing logic
+        return messages
+    
+    async def on_llm_end(self, messages):
+        """Postprocess messages after LLM call"""
+        # Add custom postprocessing logic
+        return messages
+    
+    async def on_usage(self, usage):
+        """Track usage information"""
+        print(f"Tokens used: {usage.total_tokens}")
+```
+
+## Budget Management
+
+Control costs with built-in budget management:
+
+```python
+# Simple budget limit
+agent = ComputerAgent(
+    model="anthropic/claude-3-5-sonnet-20241022",
+    max_trajectory_budget=5.0  # $5 limit
+)
+
+# Advanced budget configuration
+agent = ComputerAgent(
+    model="anthropic/claude-3-5-sonnet-20241022",
+    max_trajectory_budget={
+        "max_budget": 10.0,
+        "raise_error": True,  # Raise error when exceeded
+        "reset_after_each_run": False  # Persistent across runs
+    }
+)
+```
+
+## Trajectory Management
+
+Save and replay agent conversations:
+
+```python
+agent = ComputerAgent(
+    model="anthropic/claude-3-5-sonnet-20241022",
+    trajectory_dir="trajectories",  # Auto-save trajectories
+    tools=[computer]
+)
+
+# Trajectories are saved with:
+# - Complete conversation history
+# - Usage statistics and costs
+# - Timestamps and metadata
+# - Screenshots and computer actions
+```
+
+## Configuration Options
+
+### ComputerAgent Parameters
+
+- `model`: Model identifier (required)
+- `tools`: List of computer objects and decorated functions
+- `callbacks`: List of callback handlers for extensibility
+- `only_n_most_recent_images`: Limit recent images to prevent context overflow
+- `verbosity`: Logging level (logging.INFO, logging.DEBUG, etc.)
+- `trajectory_dir`: Directory to save conversation trajectories
+- `max_retries`: Maximum API call retries (default: 3)
+- `screenshot_delay`: Delay between actions and screenshots (default: 0.5s)
+- `use_prompt_caching`: Enable prompt caching for supported models
+- `max_trajectory_budget`: Budget limit configuration
+
+### Environment Variables
+
+```bash
+# Computer instance (cloud)
+export CUA_CONTAINER_NAME="your-container-name"
+export CUA_API_KEY="your-cua-api-key"
+
+# LLM API keys
+export ANTHROPIC_API_KEY="your-anthropic-key"
+export OPENAI_API_KEY="your-openai-key"
+```
+
+## Advanced Usage
+
+### Streaming Responses
+
+```python
+async for result in agent.run(messages, stream=True):
+    # Process streaming chunks
+    for item in result["output"]:
+        if item["type"] == "message":
+            print(item["content"][0]["text"], end="", flush=True)
+        elif item["type"] == "computer_call":
+            action = item["action"]
+            print(f"\n[Action: {action['type']}]")
+```
+
+### Interactive Chat Loop
+
+```python
+history = []
+while True:
+    user_input = input("> ")
+    if user_input.lower() in ['quit', 'exit']:
+        break
+        
+    history.append({"role": "user", "content": user_input})
+    
+    async for result in agent.run(history):
+        history += result["output"]
+        
+        # Display assistant responses
+        for item in result["output"]:
+            if item["type"] == "message":
+                print(item["content"][0]["text"])
+```
+
+### Error Handling
+
+```python
+try:
+    async for result in agent.run(messages):
+        # Process results
+        pass
+except BudgetExceededException:
+    print("Budget limit exceeded")
+except Exception as e:
+    print(f"Agent error: {e}")
+```
+
+## API Reference
+
+### ComputerAgent.run()
+
+```python
+async def run(
+    self,
+    messages: Messages,
+    stream: bool = False,
+    **kwargs
+) -> AsyncGenerator[Dict[str, Any], None]:
+    """
+    Run the agent with the given messages.
+    
+    Args:
+        messages: List of message dictionaries
+        stream: Whether to stream the response
+        **kwargs: Additional arguments
+        
+    Returns:
+        AsyncGenerator that yields response chunks
+    """
+```
+
+### Message Format
+
+```python
+messages = [
+    {
+        "role": "user",
+        "content": "Take a screenshot and describe what you see"
+    },
+    {
+        "role": "assistant", 
+        "content": "I'll take a screenshot for you."
+    }
+]
+```
+
+### Response Format
+
+```python
+{
+    "output": [
+        {
+            "type": "message",
+            "role": "assistant",
+            "content": [{"type": "output_text", "text": "I can see..."}]
+        },
+        {
+            "type": "computer_call",
+            "action": {"type": "screenshot"},
+            "call_id": "call_123"
+        },
+        {
+            "type": "computer_call_output",
+            "call_id": "call_123",
+            "output": {"image_url": "data:image/png;base64,..."}
+        }
+    ],
+    "usage": {
+        "prompt_tokens": 150,
+        "completion_tokens": 75,
+        "total_tokens": 225,
+        "response_cost": 0.01,
+    }
+}
+```
+
+## License
+
+MIT License - see LICENSE file for details.

cua_agent-0.4.0b2.dist-info/RECORD

@@ -0,0 +1,30 @@
+agent/__init__.py,sha256=rZk-enq3xJXRrl6LrpsQhJWfBtahjUP-0yY9raO72O0,356
+agent/__main__.py,sha256=lBUe8Niqa5XoCjwFfXyX7GtnUwjjZXC1-j4V9mvUYSc,538
+agent/adapters/__init__.py,sha256=szM2HMten2WkcqXeRnan__-sXjpyS4eyvIW0LXSfj4U,178
+agent/adapters/huggingfacelocal_adapter.py,sha256=dnzzxYCvFiuDdNzsb_1uM-boWv1eS__dWMve_fAnlUc,8038
+agent/agent.py,sha256=tXVnqzwC721UUN57OWEatfoZXFAzaDfrZ0G-EuVK3Ug,24022
+agent/callbacks/__init__.py,sha256=SO9NKTrmk4sZ7ZwvWFhTtK9co1FgwubUe3bwkIXYwn0,472
+agent/callbacks/base.py,sha256=UnnnYlh6XCm6HKZZsAPaT_Eyo9LUYLyjyNwF-QRm6Ns,4691
+agent/callbacks/budget_manager.py,sha256=XNrL1z3pxAZkywy6f8kfbRjDWq2ZvKcpnP2ElC8LBJs,1875
+agent/callbacks/image_retention.py,sha256=tiuRT5ke9xXTb2eP8Gz-2ITyAMY29LURUH6AbjX3RP8,6165
+agent/callbacks/logging.py,sha256=OOxU97EzrxlnUAtiEnvy9FB7SwCUK90-rdpDFA2Ae4E,10921
+agent/callbacks/pii_anonymization.py,sha256=UKAqNacHG3z92_6uocVzOIl8gJoqyofldCoCmB4UVIE,10268
+agent/callbacks/trajectory_saver.py,sha256=POE8aPT-MBzfW873wr6C7iiVUHtp483KwvLPxC1S3EY,11626
+agent/cli.py,sha256=QqIgDYjBkXf_0-bxugafxQr-Otp4avoA1SI5ZbtFhBc,9768
+agent/computer_handler.py,sha256=2gfFBeDk9Vd54x9mOqnswMo8BdjUduLo5I0RbBPLovY,3964
+agent/decorators.py,sha256=bCmcCjP31WEjWg1D91OE2jo7AZTfGa9cNgCnYUvjiyw,2832
+agent/loops/__init__.py,sha256=_qpP_--3ePdFkTZP8qmUEFlBsy6m4h8fj0gGLDKA7zw,217
+agent/loops/anthropic.py,sha256=w5s_zvkXdcHt0DgBMYjDQGDMBXK4bPu-SyeIMhA1Rrs,32243
+agent/loops/omniparser.py,sha256=qfQk9GsuSd4MAJL7mRSWv_fZBOn2dfp3HMhDuMGHKxk,11436
+agent/loops/openai.py,sha256=ArTqadeJY8F9N8ZLKfswlzgHV_54HbWJgLd4l6ele9w,3010
+agent/loops/uitars.py,sha256=L0NYxKoIiMfIHbyomnaiK3ZGLmLv3QMx9nX57GruAk0,26323
+agent/responses.py,sha256=8vnCqi21x3gzo59yDmcsA_E_-CyYxIuCwgfQF0PIomg,6867
+agent/types.py,sha256=GiLxIcF7s1XIh_WaY7tjdQPFpdTXb5MWVe_ZUPA0gkY,2364
+agent/ui/__init__.py,sha256=o7NIpZGFiCTUhgj6eB7gWRRpVhrUAsrOdWnPgbfDgVM,124
+agent/ui/gradio/__init__.py,sha256=j3dc1i14daVIDEo-3K1w_v5EyDsHeB3TdgKkuteDivM,143
+agent/ui/gradio/app.py,sha256=9i4YzLZRkvPrYKnrl6eDx1mR2QaSSsWgG-YQVlhedX8,8788
+agent/ui/gradio/ui_components.py,sha256=IZsYOwn3dwQN8E5-3cFVlLhGlu77I35YhdPY8QxB0Uk,33513
+cua_agent-0.4.0b2.dist-info/METADATA,sha256=1DV8S2V-FjsRcyszafS1cQDBuNy_M1R-MVZBoo14-aY,12062
+cua_agent-0.4.0b2.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
+cua_agent-0.4.0b2.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+cua_agent-0.4.0b2.dist-info/RECORD,,

agent/core/__init__.py

@@ -1,27 +0,0 @@
-"""Core agent components."""
-
-from .factory import BaseLoop
-from .messages import (
-    StandardMessageManager,
-    ImageRetentionConfig,
-)
-from .callbacks import (
-    CallbackManager,
-    CallbackHandler,
-    BaseCallbackManager,
-    ContentCallback,
-    ToolCallback,
-    APICallback,
-)
-
-__all__ = [
-    "BaseLoop",
-    "CallbackManager",
-    "CallbackHandler",
-    "StandardMessageManager",
-    "ImageRetentionConfig",
-    "BaseCallbackManager",
-    "ContentCallback",
-    "ToolCallback",
-    "APICallback",
-]

agent/core/agent.py

@@ -1,210 +0,0 @@
-"""Main entry point for computer agents."""
-
-import asyncio
-import logging
-import os
-from typing import AsyncGenerator, Optional
-
-from computer import Computer
-from .types import LLM, AgentLoop
-from .types import AgentResponse
-from .factory import LoopFactory
-from .provider_config import DEFAULT_MODELS, ENV_VARS
-
-logger = logging.getLogger(__name__)
-
-class ComputerAgent:
-    """A computer agent that can perform automated tasks using natural language instructions."""
-
-    def __init__(
-        self,
-        computer: Computer,
-        model: LLM,
-        loop: AgentLoop,
-        max_retries: int = 3,
-        screenshot_dir: Optional[str] = None,
-        log_dir: Optional[str] = None,
-        api_key: Optional[str] = None,
-        save_trajectory: bool = True,
-        trajectory_dir: str = "trajectories",
-        only_n_most_recent_images: Optional[int] = None,
-        verbosity: int = logging.INFO,
-    ):
-        """Initialize the ComputerAgent.
-
-        Args:
-            computer: Computer instance. If not provided, one will be created with default settings.
-            max_retries: Maximum number of retry attempts.
-            screenshot_dir: Directory to save screenshots.
-            log_dir: Directory to save logs (set to None to disable logging to files).
-            model: LLM object containing provider and model name. Takes precedence over provider/model_name.
-            provider: The AI provider to use (e.g., LLMProvider.ANTHROPIC). Only used if model is None.
-            api_key: The API key for the provider. If not provided, will look for environment variable.
-            model_name: The model name to use. Only used if model is None.
-            save_trajectory: Whether to save the trajectory.
-            trajectory_dir: Directory to save the trajectory.
-            only_n_most_recent_images: Maximum number of recent screenshots to include in API requests.
-            verbosity: Logging level.
-        """
-        # Basic agent configuration
-        self.max_retries = max_retries
-        self.computer = computer
-        self.queue = asyncio.Queue()
-        self.screenshot_dir = screenshot_dir
-        self.log_dir = log_dir
-        self._retry_count = 0
-        self._initialized = False
-        self._in_context = False
-
-        # Set logging level
-        logger.setLevel(verbosity)
-
-        # 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}")
-
-        # Use the provided LLM object
-        self.provider = model.provider
-        actual_model_name = model.name or DEFAULT_MODELS.get(self.provider, "")
-        self.provider_base_url = getattr(model, "provider_base_url", None)
-
-        # Ensure we have a valid model name
-        if not actual_model_name:
-            actual_model_name = DEFAULT_MODELS.get(self.provider, "")
-            if not actual_model_name:
-                raise ValueError(
-                    f"No model specified for provider {self.provider} and no default found"
-                )
-
-        # Get API key from environment if not provided
-        actual_api_key = api_key or os.environ.get(ENV_VARS[self.provider], "")
-        # Ollama and OpenAI-compatible APIs typically don't require an API key
-        if (
-            not actual_api_key
-            and str(self.provider) not in ["ollama", "oaicompat"]
-            and ENV_VARS[self.provider] != "none"
-        ):
-            raise ValueError(f"No API key provided for {self.provider}")
-
-        # Create the appropriate loop using the factory
-        try:
-            # Let the factory create the appropriate loop with needed components
-            self._loop = LoopFactory.create_loop(
-                loop_type=loop,
-                provider=self.provider,
-                computer=self.computer,
-                model_name=actual_model_name,
-                api_key=actual_api_key,
-                save_trajectory=save_trajectory,
-                trajectory_dir=trajectory_dir,
-                only_n_most_recent_images=only_n_most_recent_images,
-                provider_base_url=self.provider_base_url,
-            )
-        except ValueError as e:
-            logger.error(f"Failed to create loop: {str(e)}")
-            raise
-
-        # Initialize the message manager from the loop
-        self.message_manager = self._loop.message_manager
-
-        logger.info(
-            f"ComputerAgent initialized with provider: {self.provider}, model: {actual_model_name}"
-        )
-
-    async def __aenter__(self):
-        """Initialize the agent when used as a context manager."""
-        logger.info("Entering ComputerAgent context")
-        self._in_context = True
-
-        # 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()
-                await self.computer.__aenter__()
-                logger.info("Computer initialized in __aenter__")
-            else:
-                logger.info("Computer already initialized, skipping initialization")
-
-        except Exception as e:
-            logger.error(f"Error initializing computer in __aenter__: {str(e)}")
-            raise
-
-        await self.initialize()
-        return self
-
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        """Cleanup agent resources if needed."""
-        logger.info("Cleaning up agent resources")
-        self._in_context = False
-
-        # 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
-
-    async def initialize(self) -> None:
-        """Initialize the agent and its components."""
-        if not self._initialized:
-            # Always initialize the computer if available
-            if self.computer and not self.computer._initialized:
-                await self.computer.run()
-            self._initialized = True
-
-    async def run(self, task: str) -> AsyncGenerator[AgentResponse, None]:
-        """Run a task using the computer agent.
-
-        Args:
-            task: Task description
-
-        Yields:
-            Agent response format
-        """
-        try:
-            logger.info(f"Running task: {task}")
-            logger.info(
-                f"Message history before task has {len(self.message_manager.messages)} messages"
-            )
-
-            # Initialize the computer if needed
-            if not self._initialized:
-                await self.initialize()
-
-            # Add task as a user message using the message manager
-            self.message_manager.add_user_message([{"type": "text", "text": task}])
-            logger.info(
-                f"Added task message. Message history now has {len(self.message_manager.messages)} messages"
-            )
-
-            # Pass properly formatted messages to the loop
-            if self._loop is None:
-                logger.error("Loop not initialized properly")
-                yield {"error": "Loop not initialized properly"}
-                return
-
-            # Execute the task and yield results
-            async for result in self._loop.run(self.message_manager.messages):
-                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"},
-            }