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

agent/providers/anthropic/api/logging.py

@@ -1,150 +0,0 @@
-"""API logging functionality."""
-
-import json
-import logging
-from datetime import datetime
-from pathlib import Path
-import httpx
-from typing import Any
-
-logger = logging.getLogger(__name__)
-
-def _filter_base64_images(content: Any) -> Any:
-    """Filter out base64 image data from content.
-    
-    Args:
-        content: Content to filter
-        
-    Returns:
-        Filtered content with base64 data replaced by placeholder
-    """
-    if isinstance(content, dict):
-        filtered = {}
-        for key, value in content.items():
-            if (
-                isinstance(value, dict) 
-                and value.get("type") == "image" 
-                and value.get("source", {}).get("type") == "base64"
-            ):
-                # Replace base64 data with placeholder
-                filtered[key] = {
-                    **value,
-                    "source": {
-                        **value["source"],
-                        "data": "<base64_image_data>"
-                    }
-                }
-            else:
-                filtered[key] = _filter_base64_images(value)
-        return filtered
-    elif isinstance(content, list):
-        return [_filter_base64_images(item) for item in content]
-    return content
-
-def log_api_interaction(
-    request: httpx.Request | None,
-    response: httpx.Response | object | None,
-    error: Exception | None,
-    log_dir: Path = Path("/tmp/claude_logs")
-) -> None:
-    """Log API request, response, and any errors in a structured way.
-    
-    Args:
-        request: The HTTP request if available
-        response: The HTTP response or response object
-        error: Any error that occurred
-        log_dir: Directory to store log files
-    """
-    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")
-    
-    # Helper function to safely decode JSON content
-    def safe_json_decode(content):
-        if not content:
-            return None
-        try:
-            if isinstance(content, bytes):
-                return json.loads(content.decode())
-            elif isinstance(content, str):
-                return json.loads(content)
-            elif isinstance(content, dict):
-                return content
-            return None
-        except json.JSONDecodeError:
-            return {"error": "Could not decode JSON", "raw": str(content)}
-
-    # Process request content
-    request_content = None
-    if request and request.content:
-        request_content = safe_json_decode(request.content)
-        request_content = _filter_base64_images(request_content)
-
-    # Process response content
-    response_content = None
-    if response:
-        if isinstance(response, httpx.Response):
-            try:
-                response_content = response.json()
-            except json.JSONDecodeError:
-                response_content = {"error": "Could not decode JSON", "raw": response.text}
-        else:
-            response_content = safe_json_decode(response)
-        response_content = _filter_base64_images(response_content)
-
-    log_entry = {
-        "timestamp": timestamp,
-        "request": {
-            "method": request.method if request else None,
-            "url": str(request.url) if request else None,
-            "headers": dict(request.headers) if request else None,
-            "content": request_content,
-        } if request else None,
-        "response": {
-            "status_code": response.status_code if isinstance(response, httpx.Response) else None,
-            "headers": dict(response.headers) if isinstance(response, httpx.Response) else None,
-            "content": response_content,
-        } if response else None,
-        "error": {
-            "type": type(error).__name__ if error else None,
-            "message": str(error) if error else None,
-        } if error else None
-    }
-    
-    # Log to file with timestamp in filename
-    log_dir.mkdir(exist_ok=True)
-    log_file = log_dir / f"claude_api_{timestamp.replace(' ', '_').replace(':', '-')}.json"
-    
-    with open(log_file, 'w') as f:
-        json.dump(log_entry, f, indent=2)
-    
-    # Also log a summary to the console
-    if error:
-        logger.error(f"API Error at {timestamp}: {error}")
-    else:
-        logger.info(
-            f"API Call at {timestamp}: "
-            f"{request.method if request else 'No request'} -> "
-            f"{response.status_code if isinstance(response, httpx.Response) else 'No response'}"
-        )
-        
-        # Log if there are any images in the content
-        if response_content:
-            image_count = count_images(response_content)
-            if image_count > 0:
-                logger.info(f"Response contains {image_count} images")
-
-def count_images(content: dict | list | Any) -> int:
-    """Count the number of images in the content.
-    
-    Args:
-        content: Content to search for images
-        
-    Returns:
-        Number of images found
-    """
-    if isinstance(content, dict):
-        if content.get("type") == "image":
-            return 1
-        return sum(count_images(v) for v in content.values())
-    elif isinstance(content, list):
-        return sum(count_images(item) for item in content)
-    return 0 

agent/providers/anthropic/api_handler.py

@@ -1,140 +0,0 @@
-"""API call handling for Anthropic provider."""
-
-import logging
-import asyncio
-from typing import List
-
-from anthropic.types.beta import (
-    BetaMessage,
-    BetaMessageParam,
-    BetaTextBlockParam,
-)
-
-from .types import LLMProvider
-from .prompts import SYSTEM_PROMPT
-
-# Constants
-COMPUTER_USE_BETA_FLAG = "computer-use-2025-01-24"
-PROMPT_CACHING_BETA_FLAG = "prompt-caching-2024-07-31"
-
-logger = logging.getLogger(__name__)
-
-
-class AnthropicAPIHandler:
-    """Handles API calls to Anthropic's API with structured error handling and retries."""
-
-    def __init__(self, loop):
-        """Initialize the API handler.
-
-        Args:
-            loop: Reference to the parent loop instance that provides context
-        """
-        self.loop = loop
-
-    async def make_api_call(
-        self, messages: List[BetaMessageParam], system_prompt: str = SYSTEM_PROMPT
-    ) -> BetaMessage:
-        """Make API call to Anthropic with retry logic.
-
-        Args:
-            messages: List of messages to send to the API
-            system_prompt: System prompt to use (default: SYSTEM_PROMPT)
-
-        Returns:
-            API response
-
-        Raises:
-            RuntimeError: If API call fails after all retries
-        """
-        if self.loop.client is None:
-            raise RuntimeError("Client not initialized. Call initialize_client() first.")
-        if self.loop.tool_manager is None:
-            raise RuntimeError("Tool manager not initialized. Call initialize_client() first.")
-
-        last_error = None
-
-        # Add detailed debug logging to examine messages
-        logger.info(f"Sending {len(messages)} messages to Anthropic API")
-
-        # Log tool use IDs and tool result IDs for debugging
-        tool_use_ids = set()
-        tool_result_ids = set()
-
-        for i, msg in enumerate(messages):
-            logger.info(f"Message {i}: role={msg.get('role')}")
-            if isinstance(msg.get("content"), list):
-                for content_block in msg.get("content", []):
-                    if isinstance(content_block, dict):
-                        block_type = content_block.get("type")
-                        if block_type == "tool_use" and "id" in content_block:
-                            tool_id = content_block.get("id")
-                            tool_use_ids.add(tool_id)
-                            logger.info(f"  - Found tool_use with ID: {tool_id}")
-                        elif block_type == "tool_result" and "tool_use_id" in content_block:
-                            result_id = content_block.get("tool_use_id")
-                            tool_result_ids.add(result_id)
-                            logger.info(f"  - Found tool_result referencing ID: {result_id}")
-
-        # Check for mismatches
-        missing_tool_uses = tool_result_ids - tool_use_ids
-        if missing_tool_uses:
-            logger.warning(
-                f"Found tool_result IDs without matching tool_use IDs: {missing_tool_uses}"
-            )
-
-        for attempt in range(self.loop.max_retries):
-            try:
-                # Log request
-                request_data = {
-                    "messages": messages,
-                    "max_tokens": self.loop.max_tokens,
-                    "system": system_prompt,
-                }
-                # Let ExperimentManager handle sanitization
-                self.loop._log_api_call("request", request_data)
-
-                # Setup betas and system
-                system = BetaTextBlockParam(
-                    type="text",
-                    text=system_prompt,
-                )
-
-                betas = [COMPUTER_USE_BETA_FLAG]
-                # Add prompt caching if enabled in the message manager's config
-                if self.loop.message_manager.config.enable_caching:
-                    betas.append(PROMPT_CACHING_BETA_FLAG)
-                    system["cache_control"] = {"type": "ephemeral"}
-
-                # Make API call
-                response = await self.loop.client.create_message(
-                    messages=messages,
-                    system=[system],
-                    tools=self.loop.tool_manager.get_tool_params(),
-                    max_tokens=self.loop.max_tokens,
-                    betas=betas,
-                )
-
-                # Let ExperimentManager handle sanitization
-                self.loop._log_api_call("response", request_data, response)
-
-                return response
-            except Exception as e:
-                last_error = e
-                logger.error(
-                    f"Error in API call (attempt {attempt + 1}/{self.loop.max_retries}): {str(e)}"
-                )
-                self.loop._log_api_call("error", {"messages": messages}, error=e)
-
-                if attempt < self.loop.max_retries - 1:
-                    await asyncio.sleep(
-                        self.loop.retry_delay * (attempt + 1)
-                    )  # Exponential backoff
-                continue
-
-        # If we get here, all retries failed
-        error_message = f"API call failed after {self.loop.max_retries} attempts"
-        if last_error:
-            error_message += f": {str(last_error)}"
-
-        logger.error(error_message)
-        raise RuntimeError(error_message)

agent/providers/anthropic/callbacks/__init__.py

@@ -1,5 +0,0 @@
-"""Anthropic callbacks package."""
-
-from .manager import CallbackManager
-
-__all__ = ["CallbackManager"]

agent/providers/anthropic/callbacks/manager.py

@@ -1,65 +0,0 @@
-from typing import Callable, Protocol
-import httpx
-from anthropic.types.beta import BetaContentBlockParam
-from ..tools import ToolResult
-
-
-class APICallback(Protocol):
-    """Protocol for API callbacks."""
-
-    def __call__(
-        self,
-        request: httpx.Request | None,
-        response: httpx.Response | object | None,
-        error: Exception | None,
-    ) -> None: ...
-
-
-class ContentCallback(Protocol):
-    """Protocol for content callbacks."""
-
-    def __call__(self, content: BetaContentBlockParam) -> None: ...
-
-
-class ToolCallback(Protocol):
-    """Protocol for tool callbacks."""
-
-    def __call__(self, result: ToolResult, tool_id: str) -> None: ...
-
-
-class CallbackManager:
-    """Manages various callbacks for the agent system."""
-
-    def __init__(
-        self,
-        content_callback: ContentCallback,
-        tool_callback: ToolCallback,
-        api_callback: APICallback,
-    ):
-        """Initialize the callback manager.
-
-        Args:
-            content_callback: Callback for content updates
-            tool_callback: Callback for tool execution results
-            api_callback: Callback for API interactions
-        """
-        self.content_callback = content_callback
-        self.tool_callback = tool_callback
-        self.api_callback = api_callback
-
-    def on_content(self, content: BetaContentBlockParam) -> None:
-        """Handle content updates."""
-        self.content_callback(content)
-
-    def on_tool_result(self, result: ToolResult, tool_id: str) -> None:
-        """Handle tool execution results."""
-        self.tool_callback(result, tool_id)
-
-    def on_api_interaction(
-        self,
-        request: httpx.Request | None,
-        response: httpx.Response | object | None,
-        error: Exception | None,
-    ) -> None:
-        """Handle API interactions."""
-        self.api_callback(request, response, error)