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

agent/core/factory.py

@@ -1,122 +0,0 @@
-"""Base agent loop implementation."""
-
-import logging
-import importlib.util
-from typing import Dict, Optional, Type, TYPE_CHECKING, Any, cast, Callable, Awaitable
-
-from computer import Computer
-from .types import AgentLoop
-from .base import BaseLoop
-
-logger = logging.getLogger(__name__)
-
-
-class LoopFactory:
-    """Factory class for creating agent loops."""
-
-    # Registry to store loop implementations
-    _loop_registry: Dict[AgentLoop, Type[BaseLoop]] = {}
-
-    @classmethod
-    def create_loop(
-        cls,
-        loop_type: AgentLoop,
-        api_key: str,
-        model_name: str,
-        computer: Computer,
-        provider: Any = None,
-        save_trajectory: bool = True,
-        trajectory_dir: str = "trajectories",
-        only_n_most_recent_images: Optional[int] = None,
-        acknowledge_safety_check_callback: Optional[Callable[[str], Awaitable[bool]]] = None,
-        provider_base_url: Optional[str] = None,
-    ) -> BaseLoop:
-        """Create and return an appropriate loop instance based on type."""
-        if loop_type == AgentLoop.ANTHROPIC:
-            # Lazy import AnthropicLoop only when needed
-            try:
-                from ..providers.anthropic.loop import AnthropicLoop
-            except ImportError:
-                raise ImportError(
-                    "The 'anthropic' provider is not installed. "
-                    "Install it with 'pip install cua-agent[anthropic]'"
-                )
-
-            return AnthropicLoop(
-                api_key=api_key,
-                model=model_name,
-                computer=computer,
-                save_trajectory=save_trajectory,
-                base_dir=trajectory_dir,
-                only_n_most_recent_images=only_n_most_recent_images,
-            )
-        elif loop_type == AgentLoop.OPENAI:
-            # Lazy import OpenAILoop only when needed
-            try:
-                from ..providers.openai.loop import OpenAILoop
-            except ImportError:
-                raise ImportError(
-                    "The 'openai' provider is not installed. "
-                    "Install it with 'pip install cua-agent[openai]'"
-                )
-
-            return OpenAILoop(
-                api_key=api_key,
-                model=model_name,
-                computer=computer,
-                save_trajectory=save_trajectory,
-                base_dir=trajectory_dir,
-                only_n_most_recent_images=only_n_most_recent_images,
-                acknowledge_safety_check_callback=acknowledge_safety_check_callback,
-            )
-        elif loop_type == AgentLoop.OMNI:
-            # Lazy import OmniLoop and related classes only when needed
-            try:
-                from ..providers.omni.loop import OmniLoop
-                from ..providers.omni.parser import OmniParser
-                from .types import LLMProvider
-            except ImportError:
-                raise ImportError(
-                    "The 'omni' provider is not installed. "
-                    "Install it with 'pip install cua-agent[all]'"
-                )
-
-            if provider is None:
-                raise ValueError("Provider is required for OMNI loop type")
-
-            # We know provider is the correct type at this point, so cast it
-            provider_instance = cast(LLMProvider, provider)
-
-            return OmniLoop(
-                provider=provider_instance,
-                api_key=api_key,
-                model=model_name,
-                computer=computer,
-                save_trajectory=save_trajectory,
-                base_dir=trajectory_dir,
-                only_n_most_recent_images=only_n_most_recent_images,
-                parser=OmniParser(),
-                provider_base_url=provider_base_url,
-            )
-        elif loop_type == AgentLoop.UITARS:
-            # Lazy import UITARSLoop only when needed
-            try:
-                from ..providers.uitars.loop import UITARSLoop
-            except ImportError:
-                raise ImportError(
-                    "The 'uitars' provider is not installed. "
-                    "Install it with 'pip install cua-agent[all]'"
-                )
-
-            return UITARSLoop(
-                api_key=api_key,
-                model=model_name,
-                computer=computer,
-                save_trajectory=save_trajectory,
-                base_dir=trajectory_dir,
-                only_n_most_recent_images=only_n_most_recent_images,
-                provider_base_url=provider_base_url,
-                provider=provider,
-            )
-        else:
-            raise ValueError(f"Unsupported loop type: {loop_type}")

agent/core/messages.py

@@ -1,332 +0,0 @@
-"""Message handling utilities for agent."""
-
-import logging
-import json
-from typing import Any, Dict, List, Optional, Union, Tuple
-from dataclasses import dataclass
-import re
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class ImageRetentionConfig:
-    """Configuration for image retention in messages."""
-
-    num_images_to_keep: Optional[int] = None
-    min_removal_threshold: int = 1
-    enable_caching: bool = True
-
-    def should_retain_images(self) -> bool:
-        """Check if image retention is enabled."""
-        return self.num_images_to_keep is not None and self.num_images_to_keep > 0
-
-class StandardMessageManager:
-    """Manages messages in a standardized OpenAI format across different providers."""
-
-    def __init__(self, config: Optional[ImageRetentionConfig] = None):
-        """Initialize message manager.
-
-        Args:
-            config: Configuration for image retention
-        """
-        self.messages: List[Dict[str, Any]] = []
-        self.config = config or ImageRetentionConfig()
-
-    def add_user_message(self, content: Union[str, List[Dict[str, Any]]]) -> None:
-        """Add a user message.
-
-        Args:
-            content: Message content (text or multimodal content)
-        """
-        self.messages.append({"role": "user", "content": content})
-
-    def add_assistant_message(self, content: Union[str, List[Dict[str, Any]]]) -> None:
-        """Add an assistant message.
-
-        Args:
-            content: Message content (text or multimodal content)
-        """
-        self.messages.append({"role": "assistant", "content": content})
-
-    def add_system_message(self, content: str) -> None:
-        """Add a system message.
-
-        Args:
-            content: System message content
-        """
-        self.messages.append({"role": "system", "content": content})
-
-    def get_messages(self) -> List[Dict[str, Any]]:
-        """Get all messages in standard format.
-        This method applies image retention policy if configured.
-
-        Returns:
-            List of messages
-        """
-        # If image retention is configured, apply it
-        if self.config.num_images_to_keep is not None:
-            return self._apply_image_retention(self.messages)
-        return self.messages
-
-    def _apply_image_retention(self, messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
-        """Apply image retention policy to messages.
-
-        Args:
-            messages: List of messages
-
-        Returns:
-            List of messages with image retention applied
-        """
-        if not self.config.num_images_to_keep:
-            return messages
-
-        # Find messages with images (both user messages and tool call outputs)
-        image_messages = []
-        for msg in messages:
-            has_image = False
-            
-            # Check user messages with images
-            if msg["role"] == "user" and isinstance(msg["content"], list):
-                has_image = any(
-                    item.get("type") == "image_url" or item.get("type") == "image"
-                    for item in msg["content"]
-                )
-            
-            # Check assistant messages with tool calls that have images
-            elif msg["role"] == "assistant" and isinstance(msg["content"], list):
-                for item in msg["content"]:
-                    if item.get("type") == "tool_result" and "base64_image" in item:
-                        has_image = True
-                        break
-            
-            if has_image:
-                image_messages.append(msg)
-
-        # If we don't have more images than the limit, return all messages
-        if len(image_messages) <= self.config.num_images_to_keep:
-            return messages
-
-        # Get the most recent N images to keep
-        images_to_keep = image_messages[-self.config.num_images_to_keep :]
-        images_to_remove = image_messages[: -self.config.num_images_to_keep]
-
-        # Create a new message list, removing images from older messages
-        result = []
-        for msg in messages:
-            if msg in images_to_remove:
-                # Remove images from this message but keep the text content
-                if msg["role"] == "user" and isinstance(msg["content"], list):
-                    # Keep only text content, remove images
-                    new_content = [
-                        item for item in msg["content"] 
-                        if item.get("type") not in ["image_url", "image"]
-                    ]
-                    if new_content:  # Only add if there's still content
-                        result.append({"role": msg["role"], "content": new_content})
-                elif msg["role"] == "assistant" and isinstance(msg["content"], list):
-                    # Remove base64_image from tool_result items
-                    new_content = []
-                    for item in msg["content"]:
-                        if item.get("type") == "tool_result" and "base64_image" in item:
-                            # Create a copy without the base64_image
-                            new_item = {k: v for k, v in item.items() if k != "base64_image"}
-                            new_content.append(new_item)
-                        else:
-                            new_content.append(item)
-                    result.append({"role": msg["role"], "content": new_content})
-                else:
-                    # For other message types, keep as is
-                    result.append(msg)
-            else:
-                result.append(msg)
-
-        return result
-
-    def to_anthropic_format(
-        self, messages: List[Dict[str, Any]]
-    ) -> Tuple[List[Dict[str, Any]], str]:
-        """Convert standard OpenAI format messages to Anthropic format.
-
-        Args:
-            messages: List of messages in OpenAI format
-
-        Returns:
-            Tuple containing (anthropic_messages, system_content)
-        """
-        result = []
-        system_content = ""
-
-        # Process messages in order to maintain conversation flow
-        previous_assistant_tool_use_ids = (
-            set()
-        )  # Track tool_use_ids in the previous assistant message
-
-        for i, msg in enumerate(messages):
-            role = msg.get("role", "")
-            content = msg.get("content", "")
-
-            if role == "system":
-                # Collect system messages for later use
-                system_content += content + "\n"
-                continue
-
-            if role == "assistant":
-                # Track tool_use_ids in this assistant message for the next user message
-                previous_assistant_tool_use_ids = set()
-                if isinstance(content, list):
-                    for item in content:
-                        if (
-                            isinstance(item, dict)
-                            and item.get("type") == "tool_use"
-                            and "id" in item
-                        ):
-                            previous_assistant_tool_use_ids.add(item["id"])
-
-                logger.info(
-                    f"Tool use IDs in assistant message #{i}: {previous_assistant_tool_use_ids}"
-                )
-
-            if role in ["user", "assistant"]:
-                anthropic_msg = {"role": role}
-
-                # Convert content based on type
-                if isinstance(content, str):
-                    # Simple text content
-                    anthropic_msg["content"] = [{"type": "text", "text": content}]
-                elif isinstance(content, list):
-                    # Convert complex content
-                    anthropic_content = []
-                    for item in content:
-                        item_type = item.get("type", "")
-
-                        if item_type == "text":
-                            anthropic_content.append({"type": "text", "text": item.get("text", "")})
-                        elif item_type == "image_url":
-                            # Convert OpenAI image format to Anthropic
-                            image_url = item.get("image_url", {}).get("url", "")
-                            if image_url.startswith("data:"):
-                                # Extract base64 data and media type
-                                match = re.match(r"data:(.+);base64,(.+)", image_url)
-                                if match:
-                                    media_type, data = match.groups()
-                                    anthropic_content.append(
-                                        {
-                                            "type": "image",
-                                            "source": {
-                                                "type": "base64",
-                                                "media_type": media_type,
-                                                "data": data,
-                                            },
-                                        }
-                                    )
-                            else:
-                                # Regular URL
-                                anthropic_content.append(
-                                    {
-                                        "type": "image",
-                                        "source": {
-                                            "type": "url",
-                                            "url": image_url,
-                                        },
-                                    }
-                                )
-                        elif item_type == "tool_use":
-                            # Always include tool_use blocks
-                            anthropic_content.append(item)
-                        elif item_type == "tool_result":
-                            # Check if this is a user message AND if the tool_use_id exists in the previous assistant message
-                            tool_use_id = item.get("tool_use_id")
-
-                            # Only include tool_result if it references a tool_use from the immediately preceding assistant message
-                            if (
-                                role == "user"
-                                and tool_use_id
-                                and tool_use_id in previous_assistant_tool_use_ids
-                            ):
-                                anthropic_content.append(item)
-                                logger.info(
-                                    f"Including tool_result with tool_use_id: {tool_use_id}"
-                                )
-                            else:
-                                # Convert to text to preserve information
-                                logger.warning(
-                                    f"Converting tool_result to text. Tool use ID {tool_use_id} not found in previous assistant message"
-                                )
-                                content_text = "Tool Result: "
-                                if "content" in item:
-                                    if isinstance(item["content"], list):
-                                        for content_item in item["content"]:
-                                            if (
-                                                isinstance(content_item, dict)
-                                                and content_item.get("type") == "text"
-                                            ):
-                                                content_text += content_item.get("text", "")
-                                    elif isinstance(item["content"], str):
-                                        content_text += item["content"]
-                                anthropic_content.append({"type": "text", "text": content_text})
-
-                    anthropic_msg["content"] = anthropic_content
-
-                result.append(anthropic_msg)
-
-        return result, system_content
-
-    def from_anthropic_format(self, messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
-        """Convert Anthropic format messages to standard OpenAI format.
-
-        Args:
-            messages: List of messages in Anthropic format
-
-        Returns:
-            List of messages in OpenAI format
-        """
-        result = []
-
-        for msg in messages:
-            role = msg.get("role", "")
-            content = msg.get("content", [])
-
-            if role in ["user", "assistant"]:
-                openai_msg = {"role": role}
-
-                # Simple case: single text block
-                if len(content) == 1 and content[0].get("type") == "text":
-                    openai_msg["content"] = content[0].get("text", "")
-                else:
-                    # Complex case: multiple blocks or non-text
-                    openai_content = []
-                    for item in content:
-                        item_type = item.get("type", "")
-
-                        if item_type == "text":
-                            openai_content.append({"type": "text", "text": item.get("text", "")})
-                        elif item_type == "image":
-                            # Convert Anthropic image to OpenAI format
-                            source = item.get("source", {})
-                            if source.get("type") == "base64":
-                                media_type = source.get("media_type", "image/png")
-                                data = source.get("data", "")
-                                openai_content.append(
-                                    {
-                                        "type": "image_url",
-                                        "image_url": {"url": f"data:{media_type};base64,{data}"},
-                                    }
-                                )
-                            else:
-                                # URL
-                                openai_content.append(
-                                    {
-                                        "type": "image_url",
-                                        "image_url": {"url": source.get("url", "")},
-                                    }
-                                )
-                        elif item_type in ["tool_use", "tool_result"]:
-                            # Pass through tool-related content
-                            openai_content.append(item)
-
-                    openai_msg["content"] = openai_content
-
-                result.append(openai_msg)
-
-        return result

agent/core/provider_config.py

@@ -1,21 +0,0 @@
-"""Provider-specific configurations and constants."""
-
-from .types import LLMProvider
-
-# Default models for different providers
-DEFAULT_MODELS = {
-    LLMProvider.OPENAI: "gpt-4o",
-    LLMProvider.ANTHROPIC: "claude-3-7-sonnet-20250219",
-    LLMProvider.OLLAMA: "gemma3:4b-it-q4_K_M",
-    LLMProvider.OAICOMPAT: "Qwen2.5-VL-7B-Instruct",
-    LLMProvider.MLXVLM: "mlx-community/UI-TARS-1.5-7B-4bit",
-}
-
-# Map providers to their environment variable names
-ENV_VARS = {
-    LLMProvider.OPENAI: "OPENAI_API_KEY",
-    LLMProvider.ANTHROPIC: "ANTHROPIC_API_KEY",
-    LLMProvider.OLLAMA: "none",
-    LLMProvider.OAICOMPAT: "none",  # OpenAI-compatible API typically doesn't require an API key
-    LLMProvider.MLXVLM: "none",  # MLX VLM typically doesn't require an API key
-}

agent/core/telemetry.py

@@ -1,142 +0,0 @@
-"""Agent telemetry for tracking anonymous usage and feature usage."""
-
-import logging
-import os
-import platform
-import sys
-from typing import Dict, Any, Callable
-
-# Import the core telemetry module
-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
-
-
-# Define default functions with unique names to avoid shadowing
-_default_record_event = _noop
-_default_increment_counter = _noop
-_default_set_dimension = _noop
-_default_get_telemetry_client = lambda: None
-_default_flush = _noop
-_default_is_telemetry_enabled = lambda: False
-_default_is_telemetry_globally_disabled = lambda: True
-
-# Set the actual functions to the defaults initially
-record_event = _default_record_event
-increment_counter = _default_increment_counter
-set_dimension = _default_set_dimension
-get_telemetry_client = _default_get_telemetry_client
-flush = _default_flush
-is_telemetry_enabled = _default_is_telemetry_enabled
-is_telemetry_globally_disabled = _default_is_telemetry_globally_disabled
-
-logger = logging.getLogger("agent.telemetry")
-
-try:
-    # Import from core telemetry
-    from core.telemetry import (
-        record_event as core_record_event,
-        increment as core_increment,
-        get_telemetry_client as core_get_telemetry_client,
-        flush as core_flush,
-        is_telemetry_enabled as core_is_telemetry_enabled,
-        is_telemetry_globally_disabled as core_is_telemetry_globally_disabled,
-    )
-
-    # Override the default functions with actual implementations
-    record_event = core_record_event
-    get_telemetry_client = core_get_telemetry_client
-    flush = core_flush
-    is_telemetry_enabled = core_is_telemetry_enabled
-    is_telemetry_globally_disabled = core_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():
-            core_increment(counter_name, value)
-
-    def set_dimension(name: str, value: Any) -> None:
-        """Set a dimension that will be attached to all events."""
-        logger.debug(f"Setting dimension {name}={value}")
-
-    TELEMETRY_AVAILABLE = True
-    logger.info("Successfully imported telemetry")
-except ImportError as e:
-    logger.warning(f"Could not import telemetry: {e}")
-    logger.debug("Telemetry not available, using no-op functions")
-
-# 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, record_event, increment_counter, get_telemetry_client, flush, is_telemetry_enabled, is_telemetry_globally_disabled
-
-    # 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 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/core/tools/__init__.py

@@ -1,21 +0,0 @@
-"""Core tools package."""
-
-from .base import BaseTool, ToolResult, ToolError, ToolFailure, CLIResult
-from .bash import BaseBashTool
-from .collection import ToolCollection
-from .computer import BaseComputerTool
-from .edit import BaseEditTool
-from .manager import BaseToolManager
-
-__all__ = [
-    "BaseTool",
-    "ToolResult",
-    "ToolError",
-    "ToolFailure",
-    "CLIResult",
-    "BaseBashTool",
-    "BaseComputerTool",
-    "BaseEditTool",
-    "ToolCollection",
-    "BaseToolManager",
-]