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

agent/core/tools/base.py

@@ -1,74 +0,0 @@
-"""Abstract base classes for tools that can be used with any provider."""
-
-from abc import ABCMeta, abstractmethod
-from dataclasses import dataclass, fields, replace
-from typing import Any, Dict
-
-
-class BaseTool(metaclass=ABCMeta):
-    """Abstract base class for provider-agnostic tools."""
-
-    name: str
-
-    @abstractmethod
-    async def __call__(self, **kwargs) -> Any:
-        """Executes the tool with the given arguments."""
-        ...
-
-    @abstractmethod
-    def to_params(self) -> Dict[str, Any]:
-        """Convert tool to provider-specific API parameters.
-
-        Returns:
-            Dictionary with tool parameters specific to the LLM provider
-        """
-        raise NotImplementedError
-
-
-@dataclass(kw_only=True, frozen=True)
-class ToolResult:
-    """Represents the result of a tool execution."""
-
-    output: str | None = None
-    error: str | None = None
-    base64_image: str | None = None
-    system: str | None = None
-    content: list[dict] | None = None
-
-    def __bool__(self):
-        return any(getattr(self, field.name) for field in fields(self))
-
-    def __add__(self, other: "ToolResult"):
-        def combine_fields(field: str | None, other_field: str | None, concatenate: bool = True):
-            if field and other_field:
-                if concatenate:
-                    return field + other_field
-                raise ValueError("Cannot combine tool results")
-            return field or other_field
-
-        return ToolResult(
-            output=combine_fields(self.output, other.output),
-            error=combine_fields(self.error, other.error),
-            base64_image=combine_fields(self.base64_image, other.base64_image, False),
-            system=combine_fields(self.system, other.system),
-            content=self.content or other.content,  # Use first non-None content
-        )
-
-    def replace(self, **kwargs):
-        """Returns a new ToolResult with the given fields replaced."""
-        return replace(self, **kwargs)
-
-
-class CLIResult(ToolResult):
-    """A ToolResult that can be rendered as a CLI output."""
-
-
-class ToolFailure(ToolResult):
-    """A ToolResult that represents a failure."""
-
-
-class ToolError(Exception):
-    """Raised when a tool encounters an error."""
-
-    def __init__(self, message):
-        self.message = message

agent/core/tools/bash.py

@@ -1,52 +0,0 @@
-"""Abstract base bash/shell tool implementation."""
-
-import asyncio
-import logging
-from abc import abstractmethod
-from typing import Any, Dict, Tuple
-
-from computer.computer import Computer
-
-from .base import BaseTool, ToolResult
-
-
-class BaseBashTool(BaseTool):
-    """Base class for bash/shell command execution tools across different providers."""
-
-    name = "bash"
-    logger = logging.getLogger(__name__)
-    computer: Computer
-
-    def __init__(self, computer: Computer):
-        """Initialize the BashTool.
-
-        Args:
-            computer: Computer instance, may be used for related operations
-        """
-        self.computer = computer
-
-    async def run_command(self, command: str) -> Tuple[int, str, str]:
-        """Run a shell command and return exit code, stdout, and stderr.
-
-        Args:
-            command: Shell command to execute
-
-        Returns:
-            Tuple containing (exit_code, stdout, stderr)
-        """
-        try:
-            process = await asyncio.create_subprocess_shell(
-                command,
-                stdout=asyncio.subprocess.PIPE,
-                stderr=asyncio.subprocess.PIPE,
-            )
-            stdout, stderr = await process.communicate()
-            return process.returncode or 0, stdout.decode(), stderr.decode()
-        except Exception as e:
-            self.logger.error(f"Error running command: {str(e)}")
-            return 1, "", str(e)
-
-    @abstractmethod
-    async def __call__(self, **kwargs) -> ToolResult:
-        """Execute the tool with the provided arguments."""
-        raise NotImplementedError

agent/core/tools/collection.py

@@ -1,46 +0,0 @@
-"""Collection classes for managing multiple tools."""
-
-from typing import Any, Dict, List, Type
-
-from .base import (
-    BaseTool,
-    ToolError,
-    ToolFailure,
-    ToolResult,
-)
-
-
-class ToolCollection:
-    """A collection of tools that can be used with any provider."""
-
-    def __init__(self, *tools: BaseTool):
-        self.tools = tools
-        self.tool_map = {tool.name: tool for tool in tools}
-
-    def to_params(self) -> List[Dict[str, Any]]:
-        """Convert all tools to provider-specific parameters.
-
-        Returns:
-            List of dictionaries with tool parameters
-        """
-        return [tool.to_params() for tool in self.tools]
-
-    async def run(self, *, name: str, tool_input: Dict[str, Any]) -> ToolResult:
-        """Run a tool with the given input.
-
-        Args:
-            name: Name of the tool to run
-            tool_input: Input parameters for the tool
-
-        Returns:
-            Result of the tool execution
-        """
-        tool = self.tool_map.get(name)
-        if not tool:
-            return ToolFailure(error=f"Tool {name} is invalid")
-        try:
-            return await tool(**tool_input)
-        except ToolError as e:
-            return ToolFailure(error=e.message)
-        except Exception as e:
-            return ToolFailure(error=f"Unexpected error in tool {name}: {str(e)}")

agent/core/tools/computer.py

@@ -1,113 +0,0 @@
-"""Abstract base computer tool implementation."""
-
-import asyncio
-import base64
-import io
-import logging
-from abc import abstractmethod
-from typing import Any, Dict, Optional, Tuple
-
-from PIL import Image
-from computer.computer import Computer
-
-from .base import BaseTool, ToolError, ToolResult
-
-
-class BaseComputerTool(BaseTool):
-    """Base class for computer interaction tools across different providers."""
-
-    name = "computer"
-    logger = logging.getLogger(__name__)
-
-    width: Optional[int] = None
-    height: Optional[int] = None
-    display_num: Optional[int] = None
-    computer: Computer
-
-    _screenshot_delay = 1.0  # Default delay for most platforms
-    _scaling_enabled = True
-
-    def __init__(self, computer: Computer):
-        """Initialize the ComputerTool.
-
-        Args:
-            computer: Computer instance for screen interactions
-        """
-        self.computer = computer
-
-    async def initialize_dimensions(self):
-        """Initialize screen dimensions from the computer interface."""
-        display_size = await self.computer.interface.get_screen_size()
-        self.width = display_size["width"]
-        self.height = display_size["height"]
-        self.logger.info(f"Initialized screen dimensions to {self.width}x{self.height}")
-
-    @property
-    def options(self) -> Dict[str, Any]:
-        """Get the options for the tool.
-
-        Returns:
-            Dictionary with tool options
-        """
-        if self.width is None or self.height is None:
-            raise RuntimeError(
-                "Screen dimensions not initialized. Call initialize_dimensions() first."
-            )
-        return {
-            "display_width_px": self.width,
-            "display_height_px": self.height,
-            "display_number": self.display_num,
-        }
-
-    async def resize_screenshot_if_needed(self, screenshot: bytes) -> bytes:
-        """Resize a screenshot to match the expected dimensions.
-
-        Args:
-            screenshot: Raw screenshot data
-
-        Returns:
-            Resized screenshot data
-        """
-        if self.width is None or self.height is None:
-            raise ToolError("Screen dimensions not initialized")
-
-        try:
-            img = Image.open(io.BytesIO(screenshot))
-            if img.mode in ("RGBA", "LA") or (img.mode == "P" and "transparency" in img.info):
-                img = img.convert("RGB")
-
-            # Resize if dimensions don't match
-            if img.size != (self.width, self.height):
-                self.logger.info(
-                    f"Scaling image from {img.size} to {self.width}x{self.height} to match screen dimensions"
-                )
-                img = img.resize((self.width, self.height), Image.Resampling.LANCZOS)
-
-                # Save back to bytes
-                buffer = io.BytesIO()
-                img.save(buffer, format="PNG")
-                return buffer.getvalue()
-
-            return screenshot
-        except Exception as e:
-            self.logger.error(f"Error during screenshot resizing: {str(e)}")
-            raise ToolError(f"Failed to resize screenshot: {str(e)}")
-
-    async def screenshot(self) -> ToolResult:
-        """Take a screenshot and return it as a ToolResult with base64-encoded image.
-
-        Returns:
-            ToolResult with the screenshot
-        """
-        try:
-            screenshot = await self.computer.interface.screenshot()
-            screenshot = await self.resize_screenshot_if_needed(screenshot)
-            return ToolResult(base64_image=base64.b64encode(screenshot).decode())
-        except Exception as e:
-            self.logger.error(f"Error taking screenshot: {str(e)}")
-            return ToolResult(error=f"Failed to take screenshot: {str(e)}")
-
-    @abstractmethod
-    async def __call__(self, **kwargs) -> ToolResult:
-        """Execute the tool with the provided arguments."""
-        raise NotImplementedError

agent/core/tools/edit.py

@@ -1,67 +0,0 @@
-"""Abstract base edit tool implementation."""
-
-import asyncio
-import logging
-import os
-from abc import abstractmethod
-from pathlib import Path
-from typing import Any, Dict, Optional
-
-from computer.computer import Computer
-
-from .base import BaseTool, ToolError, ToolResult
-
-
-class BaseEditTool(BaseTool):
-    """Base class for text editor tools across different providers."""
-
-    name = "edit"
-    logger = logging.getLogger(__name__)
-    computer: Computer
-
-    def __init__(self, computer: Computer):
-        """Initialize the EditTool.
-
-        Args:
-            computer: Computer instance, may be used for related operations
-        """
-        self.computer = computer
-
-    async def read_file(self, path: str) -> str:
-        """Read a file and return its contents.
-
-        Args:
-            path: Path to the file to read
-
-        Returns:
-            File contents as a string
-        """
-        try:
-            path_obj = Path(path)
-            if not path_obj.exists():
-                raise ToolError(f"File does not exist: {path}")
-            return path_obj.read_text()
-        except Exception as e:
-            self.logger.error(f"Error reading file: {str(e)}")
-            raise ToolError(f"Failed to read file: {str(e)}")
-
-    async def write_file(self, path: str, content: str) -> None:
-        """Write content to a file.
-
-        Args:
-            path: Path to the file to write
-            content: Content to write to the file
-        """
-        try:
-            path_obj = Path(path)
-            # Create parent directories if they don't exist
-            path_obj.parent.mkdir(parents=True, exist_ok=True)
-            path_obj.write_text(content)
-        except Exception as e:
-            self.logger.error(f"Error writing file: {str(e)}")
-            raise ToolError(f"Failed to write file: {str(e)}")
-
-    @abstractmethod
-    async def __call__(self, **kwargs) -> ToolResult:
-        """Execute the tool with the provided arguments."""
-        raise NotImplementedError

agent/core/tools/manager.py

@@ -1,56 +0,0 @@
-"""Tool manager for initializing and running tools."""
-
-from abc import ABC, abstractmethod
-from typing import Any, Dict, List
-
-from computer.computer import Computer
-
-from .base import BaseTool, ToolResult
-from .collection import ToolCollection
-
-
-class BaseToolManager(ABC):
-    """Base class for tool managers across different providers."""
-
-    def __init__(self, computer: Computer):
-        """Initialize the tool manager.
-
-        Args:
-            computer: Computer instance for computer-related tools
-        """
-        self.computer = computer
-        self.tools: ToolCollection | None = None
-
-    @abstractmethod
-    def _initialize_tools(self) -> ToolCollection:
-        """Initialize all available tools."""
-        ...
-
-    async def initialize(self) -> None:
-        """Initialize tool-specific requirements and create tool collection."""
-        await self._initialize_tools_specific()
-        self.tools = self._initialize_tools()
-
-    @abstractmethod
-    async def _initialize_tools_specific(self) -> None:
-        """Initialize provider-specific tool requirements."""
-        ...
-
-    @abstractmethod
-    def get_tool_params(self) -> List[Dict[str, Any]]:
-        """Get tool parameters for API calls."""
-        ...
-
-    async def execute_tool(self, name: str, tool_input: Dict[str, Any]) -> ToolResult:
-        """Execute a tool with the given input.
-
-        Args:
-            name: Name of the tool to execute
-            tool_input: Input parameters for the tool
-
-        Returns:
-            Result of the tool execution
-        """
-        if self.tools is None:
-            raise RuntimeError("Tools not initialized. Call initialize() first.")
-        return await self.tools.run(name=name, tool_input=tool_input)

agent/core/tools.py

@@ -1,32 +0,0 @@
-"""Tool-related type definitions."""
-
-from enum import StrEnum
-from typing import Dict, Any, Optional
-from pydantic import BaseModel, ConfigDict
-
-class ToolInvocationState(StrEnum):
-    """States for tool invocation."""
-    CALL = 'call'
-    PARTIAL_CALL = 'partial-call'
-    RESULT = 'result'
-
-class ToolInvocation(BaseModel):
-    """Tool invocation type."""
-    model_config = ConfigDict(extra='forbid')
-    state: Optional[str] = None
-    toolCallId: str
-    toolName: Optional[str] = None
-    args: Optional[Dict[str, Any]] = None
-
-class ClientAttachment(BaseModel):
-    """Client attachment type."""
-    name: str
-    contentType: str
-    url: str
-
-class ToolResult(BaseModel):
-    """Result of a tool execution."""
-    model_config = ConfigDict(extra='forbid')
-    output: Optional[str] = None
-    error: Optional[str] = None
-    metadata: Optional[Dict[str, Any]] = None

agent/core/types.py

@@ -1,88 +0,0 @@
-"""Core type definitions."""
-
-from typing import Any, Dict, List, Optional, TypedDict, Union
-from enum import StrEnum
-from dataclasses import dataclass
-
-
-class AgentLoop(StrEnum):
-    """Enumeration of available loop types."""
-
-    ANTHROPIC = "anthropic"  # Anthropic implementation
-    OMNI = "omni"  # OmniLoop implementation
-    OPENAI = "openai"  # OpenAI implementation
-    OLLAMA = "ollama"  # OLLAMA implementation
-    UITARS = "uitars"  # UI-TARS implementation
-    # Add more loop types as needed
-
-
-class LLMProvider(StrEnum):
-    """Supported LLM providers."""
-
-    ANTHROPIC = "anthropic"
-    OPENAI = "openai"
-    OLLAMA = "ollama"
-    OAICOMPAT = "oaicompat"
-    MLXVLM= "mlxvlm"
-
-
-@dataclass
-class LLM:
-    """Configuration for LLM model and provider."""
-
-    provider: LLMProvider
-    name: Optional[str] = None
-    provider_base_url: Optional[str] = None
-
-    def __post_init__(self):
-        """Set default model name if not provided."""
-        if self.name is None:
-            from .provider_config import DEFAULT_MODELS
-
-            self.name = DEFAULT_MODELS.get(self.provider)
-
-        # Set default provider URL if none provided
-        if self.provider_base_url is None and self.provider == LLMProvider.OAICOMPAT:
-            # Default for vLLM
-            self.provider_base_url = "http://localhost:8000/v1"
-            # Common alternatives:
-            # - LM Studio: "http://localhost:1234/v1"
-            # - LocalAI: "http://localhost:8080/v1"
-            # - Ollama with OpenAI compatible API: "http://localhost:11434/v1"
-
-
-# For backward compatibility
-LLMModel = LLM
-Model = LLM
-
-
-class AgentResponse(TypedDict, total=False):
-    """Agent response format."""
-
-    id: str
-    object: str
-    created_at: int
-    status: str
-    error: Optional[str]
-    incomplete_details: Optional[Any]
-    instructions: Optional[Any]
-    max_output_tokens: Optional[int]
-    model: str
-    output: List[Dict[str, Any]]
-    parallel_tool_calls: bool
-    previous_response_id: Optional[str]
-    reasoning: Dict[str, str]
-    store: bool
-    temperature: float
-    text: Dict[str, Dict[str, str]]
-    tool_choice: str
-    tools: List[Dict[str, Union[str, int]]]
-    top_p: float
-    truncation: str
-    usage: Dict[str, Any]
-    user: Optional[str]
-    metadata: Dict[str, Any]
-    response: Dict[str, List[Dict[str, Any]]]
-    # Additional fields for error responses
-    role: str
-    content: Union[str, List[Dict[str, Any]]]