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

agent/providers/anthropic/response_handler.py

@@ -1,226 +0,0 @@
-"""Response and tool handling for Anthropic provider."""
-
-import logging
-from typing import Any, Dict, List, Tuple, cast
-
-from anthropic.types.beta import (
-    BetaMessage,
-    BetaTextBlock,
-    BetaContentBlockParam,
-)
-
-from .tools import ToolResult
-
-logger = logging.getLogger(__name__)
-
-
-class AnthropicResponseHandler:
-    """Handles Anthropic API responses and tool execution results."""
-
-    def __init__(self, loop):
-        """Initialize the response handler.
-
-        Args:
-            loop: Reference to the parent loop instance that provides context
-        """
-        self.loop = loop
-
-    async def handle_response(
-        self, response: BetaMessage, messages: List[Dict[str, Any]]
-    ) -> Tuple[List[Dict[str, Any]], bool]:
-        """Handle the Anthropic API response.
-
-        Args:
-            response: API response
-            messages: List of messages for context
-
-        Returns:
-            Tuple containing:
-            - List of new messages to be added
-            - Boolean indicating if the loop should continue
-        """
-        try:
-            new_messages = []
-
-            # Convert response to parameter format
-            response_params = self.response_to_params(response)
-
-            # Collect all existing tool_use IDs from previous messages for validation
-            existing_tool_use_ids = set()
-            for msg in messages:
-                if msg.get("role") == "assistant" and isinstance(msg.get("content"), list):
-                    for block in msg.get("content", []):
-                        if (
-                            isinstance(block, dict)
-                            and block.get("type") == "tool_use"
-                            and "id" in block
-                        ):
-                            existing_tool_use_ids.add(block["id"])
-
-            # Also add new tool_use IDs from the current response
-            current_tool_use_ids = set()
-            for block in response_params:
-                if isinstance(block, dict) and block.get("type") == "tool_use" and "id" in block:
-                    current_tool_use_ids.add(block["id"])
-                    existing_tool_use_ids.add(block["id"])
-
-            logger.info(f"Existing tool_use IDs in conversation: {existing_tool_use_ids}")
-            logger.info(f"New tool_use IDs in current response: {current_tool_use_ids}")
-
-            # Create assistant message
-            new_messages.append(
-                {
-                    "role": "assistant",
-                    "content": response_params,
-                }
-            )
-
-            if self.loop.callback_manager is None:
-                raise RuntimeError(
-                    "Callback manager not initialized. Call initialize_client() first."
-                )
-
-            # Handle tool use blocks and collect results
-            tool_result_content = []
-            for content_block in response_params:
-                # Notify callback of content
-                self.loop.callback_manager.on_content(cast(BetaContentBlockParam, content_block))
-
-                # Handle tool use
-                if content_block.get("type") == "tool_use":
-                    if self.loop.tool_manager is None:
-                        raise RuntimeError(
-                            "Tool manager not initialized. Call initialize_client() first."
-                        )
-
-                    # Execute the tool
-                    result = await self.loop.tool_manager.execute_tool(
-                        name=content_block["name"],
-                        tool_input=cast(Dict[str, Any], content_block["input"]),
-                    )
-
-                    # Verify the tool_use ID exists in the conversation (which it should now)
-                    tool_use_id = content_block["id"]
-                    if tool_use_id in existing_tool_use_ids:
-                        # Create tool result and add to content
-                        tool_result = self.make_tool_result(cast(ToolResult, result), tool_use_id)
-                        tool_result_content.append(tool_result)
-
-                        # Notify callback of tool result
-                        self.loop.callback_manager.on_tool_result(
-                            cast(ToolResult, result), content_block["id"]
-                        )
-                    else:
-                        logger.warning(
-                            f"Tool use ID {tool_use_id} not found in previous messages. Skipping tool result."
-                        )
-
-            # If no tool results, we're done
-            if not tool_result_content:
-                # Signal completion
-                self.loop.callback_manager.on_content({"type": "text", "text": "<DONE>"})
-                return new_messages, False
-
-            # Add tool results as user message
-            new_messages.append({"content": tool_result_content, "role": "user"})
-            return new_messages, True
-
-        except Exception as e:
-            logger.error(f"Error handling response: {str(e)}")
-            new_messages.append(
-                {
-                    "role": "assistant",
-                    "content": f"Error: {str(e)}",
-                }
-            )
-            return new_messages, False
-
-    def response_to_params(
-        self,
-        response: BetaMessage,
-    ) -> List[Dict[str, Any]]:
-        """Convert API response to message parameters.
-
-        Args:
-            response: API response message
-
-        Returns:
-            List of content blocks
-        """
-        result = []
-        for block in response.content:
-            if isinstance(block, BetaTextBlock):
-                result.append({"type": "text", "text": block.text})
-            else:
-                result.append(cast(Dict[str, Any], block.model_dump()))
-        return result
-
-    def make_tool_result(self, result: ToolResult, tool_use_id: str) -> Dict[str, Any]:
-        """Convert a tool result to API format.
-
-        Args:
-            result: Tool execution result
-            tool_use_id: ID of the tool use
-
-        Returns:
-            Formatted tool result
-        """
-        if result.content:
-            return {
-                "type": "tool_result",
-                "content": result.content,
-                "tool_use_id": tool_use_id,
-                "is_error": bool(result.error),
-            }
-
-        tool_result_content = []
-        is_error = False
-
-        if result.error:
-            is_error = True
-            tool_result_content = [
-                {
-                    "type": "text",
-                    "text": self.maybe_prepend_system_tool_result(result, result.error),
-                }
-            ]
-        else:
-            if result.output:
-                tool_result_content.append(
-                    {
-                        "type": "text",
-                        "text": self.maybe_prepend_system_tool_result(result, result.output),
-                    }
-                )
-            if result.base64_image:
-                tool_result_content.append(
-                    {
-                        "type": "image",
-                        "source": {
-                            "type": "base64",
-                            "media_type": "image/png",
-                            "data": result.base64_image,
-                        },
-                    }
-                )
-
-        return {
-            "type": "tool_result",
-            "content": tool_result_content,
-            "tool_use_id": tool_use_id,
-            "is_error": is_error,
-        }
-
-    def maybe_prepend_system_tool_result(self, result: ToolResult, result_text: str) -> str:
-        """Prepend system information to tool result if available.
-
-        Args:
-            result: Tool execution result
-            result_text: Text to prepend to
-
-        Returns:
-            Text with system information prepended if available
-        """
-        if result.system:
-            result_text = f"<s>{result.system}</s>\n{result_text}"
-        return result_text

agent/providers/anthropic/tools/__init__.py

@@ -1,33 +0,0 @@
-"""Anthropic-specific tools for agent."""
-
-from .base import (
-    BaseAnthropicTool,
-    ToolResult,
-    ToolError,
-    ToolFailure,
-    CLIResult,
-    AnthropicToolResult,
-    AnthropicToolError,
-    AnthropicToolFailure,
-    AnthropicCLIResult,
-)
-from .bash import BashTool
-from .computer import ComputerTool
-from .edit import EditTool
-from .manager import ToolManager
-
-__all__ = [
-    "BaseAnthropicTool",
-    "ToolResult",
-    "ToolError",
-    "ToolFailure",
-    "CLIResult",
-    "AnthropicToolResult",
-    "AnthropicToolError",
-    "AnthropicToolFailure",
-    "AnthropicCLIResult",
-    "BashTool",
-    "ComputerTool",
-    "EditTool",
-    "ToolManager",
-]

agent/providers/anthropic/tools/base.py

@@ -1,88 +0,0 @@
-"""Anthropic-specific tool base classes."""
-
-from abc import ABCMeta, abstractmethod
-from dataclasses import dataclass, fields, replace
-from typing import Any, Dict
-
-from anthropic.types.beta import BetaToolUnionParam
-
-from ....core.tools.base import BaseTool
-
-
-class BaseAnthropicTool(BaseTool, metaclass=ABCMeta):
-    """Abstract base class for Anthropic-defined tools."""
-
-    def __init__(self):
-        """Initialize the base Anthropic tool."""
-        # No specific initialization needed yet, but included for future extensibility
-        pass
-
-    @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 Anthropic-specific API parameters.
-
-        Returns:
-            Dictionary with tool parameters for Anthropic API
-        """
-        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
-
-
-# Re-export the core tool classes with Anthropic-specific names for backward compatibility
-AnthropicToolResult = ToolResult
-AnthropicToolError = ToolError
-AnthropicToolFailure = ToolFailure
-AnthropicCLIResult = CLIResult

agent/providers/anthropic/tools/bash.py

@@ -1,66 +0,0 @@
-import asyncio
-import os
-from typing import ClassVar, Literal, Dict, Any
-from computer.computer import Computer
-
-from .base import BaseAnthropicTool, CLIResult, ToolError, ToolResult
-from ....core.tools.bash import BaseBashTool
-
-
-class BashTool(BaseBashTool, BaseAnthropicTool):
-    """
-    A tool that allows the agent to run bash commands.
-    The tool parameters are defined by Anthropic and are not editable.
-    """
-
-    name: ClassVar[Literal["bash"]] = "bash"
-    api_type: ClassVar[Literal["bash_20250124"]] = "bash_20250124"
-    _timeout: float = 120.0  # seconds
-
-    def __init__(self, computer: Computer):
-        """Initialize the bash tool.
-
-        Args:
-            computer: Computer instance for executing commands
-        """
-        # Initialize the base bash tool first
-        BaseBashTool.__init__(self, computer)
-        # Then initialize the Anthropic tool
-        BaseAnthropicTool.__init__(self)
-        # Initialize bash session
-
-    async def __call__(self, command: str | None = None, restart: bool = False, **kwargs):
-        """Execute a bash command.
-
-        Args:
-            command: The command to execute
-            restart: Whether to restart the shell (not used with computer interface)
-
-        Returns:
-            Tool execution result
-
-        Raises:
-            ToolError: If command execution fails
-        """
-        if restart:
-            return ToolResult(system="Restart not needed with computer interface.")
-
-        if command is None:
-            raise ToolError("no command provided.")
-
-        try:
-            async with asyncio.timeout(self._timeout):
-                result = await self.computer.interface.run_command(command)
-                return CLIResult(output=result.stdout or "", error=result.stderr or "")
-        except asyncio.TimeoutError as e:
-            raise ToolError(f"Command timed out after {self._timeout} seconds") from e
-        except Exception as e:
-            raise ToolError(f"Failed to execute command: {str(e)}")
-
-    def to_params(self) -> Dict[str, Any]:
-        """Convert tool to API parameters.
-
-        Returns:
-            Dictionary with tool parameters
-        """
-        return {"name": self.name, "type": self.api_type}

agent/providers/anthropic/tools/collection.py

@@ -1,34 +0,0 @@
-"""Collection classes for managing multiple tools."""
-
-from typing import Any, cast
-
-from anthropic.types.beta import BetaToolUnionParam
-
-from .base import (
-    BaseAnthropicTool,
-    ToolError,
-    ToolFailure,
-    ToolResult,
-)
-
-
-class ToolCollection:
-    """A collection of anthropic-defined tools."""
-
-    def __init__(self, *tools: BaseAnthropicTool):
-        self.tools = tools
-        self.tool_map = {tool.to_params()["name"]: tool for tool in tools}
-
-    def to_params(
-        self,
-    ) -> list[BetaToolUnionParam]:
-        return cast(list[BetaToolUnionParam], [tool.to_params() for tool in self.tools])
-
-    async def run(self, *, name: str, tool_input: dict[str, Any]) -> ToolResult:
-        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)