orgo 0.0.32__py3-none-any.whl

orgo/__init__.py

@@ -0,0 +1,7 @@
+# src/orgo/__init__.py
+"""Orgo SDK: Desktop infrastructure for AI agents"""
+
+from .project import Project
+from .computer import Computer
+
+__all__ = ["Project", "Computer"]

orgo/api/__init__.py

@@ -0,0 +1,6 @@
+# src/orgo/api/__init__.py
+"""API package for Orgo SDK"""
+
+from .client import ApiClient
+
+__all__ = ["ApiClient"]

orgo/api/client.py

@@ -0,0 +1,183 @@
+"""API client for Orgo service"""
+
+import requests
+from typing import Dict, Any, Optional, List
+import logging
+
+from orgo.utils.auth import get_api_key
+
+logger = logging.getLogger(__name__)
+
+class ApiClient:
+    def __init__(self, api_key: Optional[str] = None, base_url: Optional[str] = None):
+        self.api_key = get_api_key(api_key)
+        self.base_url = base_url or "https://www.orgo.ai/api"
+        self.session = requests.Session()
+        self.session.headers.update({
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+            "Accept": "application/json"
+        })
+    
+    def _request(self, method: str, endpoint: str, data: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        url = f"{self.base_url}/{endpoint}"
+        
+        try:
+            if method.upper() == "GET":
+                response = self.session.get(url, params=data)
+            else:
+                response = self.session.request(method, url, json=data)
+            
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.RequestException as e:
+            # Log the full error for debugging
+            logger.debug(f"API request failed: {method} {url}", exc_info=True)
+            
+            if hasattr(e, 'response') and e.response is not None:
+                try:
+                    error_data = e.response.json()
+                    if 'error' in error_data:
+                        raise Exception(error_data['error']) from None
+                except (ValueError, KeyError):
+                    pass
+                raise Exception(f"Request failed with status {e.response.status_code}") from None
+            
+            # Generic error message without exposing internal details
+            raise Exception("Failed to connect to Orgo service. Please check your connection and try again.") from None
+    
+    # Project methods
+    def create_project(self, name: str) -> Dict[str, Any]:
+        """Create a new named project"""
+        return self._request("POST", "projects", {"name": name})
+    
+    def get_project_by_name(self, name: str) -> Dict[str, Any]:
+        """Get project details by name"""
+        projects = self.list_projects()
+        for project in projects:
+            if project.get("name") == name:
+                return project
+        raise Exception(f"Project '{name}' not found") from None
+    
+    def get_project(self, project_id: str) -> Dict[str, Any]:
+        """Get project details by ID"""
+        return self._request("GET", f"projects/{project_id}")
+    
+    def list_projects(self) -> List[Dict[str, Any]]:
+        """List all projects"""
+        response = self._request("GET", "projects")
+        return response.get("projects", [])
+    
+    def delete_project(self, project_id: str) -> Dict[str, Any]:
+        """Delete a project and all its computers"""
+        return self._request("DELETE", f"projects/{project_id}")
+    
+    # Computer methods
+    def create_computer(self, project_id: str, computer_name: str, 
+                       os: str = "linux", ram: int = 2, cpu: int = 2, 
+                       gpu: str = "none") -> Dict[str, Any]:
+        """Create a new computer within a project"""
+        return self._request("POST", "computers", {
+            "project_id": project_id,
+            "name": computer_name,
+            "os": os,
+            "ram": ram,
+            "cpu": cpu,
+            "gpu": gpu
+        })
+    
+    def list_computers(self, project_id: str) -> List[Dict[str, Any]]:
+        """List all computers in a project"""
+        project = self.get_project(project_id)
+        return project.get("desktops", [])
+    
+    def get_computer(self, computer_id: str) -> Dict[str, Any]:
+        """Get computer details"""
+        return self._request("GET", f"computers/{computer_id}")
+    
+    def delete_computer(self, computer_id: str) -> Dict[str, Any]:
+        """Delete a computer"""
+        return self._request("DELETE", f"computers/{computer_id}")
+    
+    def restart_computer(self, computer_id: str) -> Dict[str, Any]:
+        """Restart a computer"""
+        return self._request("POST", f"computers/{computer_id}/restart")
+    
+    # Computer control methods
+    def left_click(self, computer_id: str, x: int, y: int) -> Dict[str, Any]:
+        return self._request("POST", f"computers/{computer_id}/click", {
+            "button": "left", "x": x, "y": y
+        })
+    
+    def right_click(self, computer_id: str, x: int, y: int) -> Dict[str, Any]:
+        return self._request("POST", f"computers/{computer_id}/click", {
+            "button": "right", "x": x, "y": y
+        })
+    
+    def double_click(self, computer_id: str, x: int, y: int) -> Dict[str, Any]:
+        return self._request("POST", f"computers/{computer_id}/click", {
+            "button": "left", "x": x, "y": y, "double": True
+        })
+    
+    def drag(self, computer_id: str, start_x: int, start_y: int, 
+             end_x: int, end_y: int, button: str = "left", 
+             duration: float = 0.5) -> Dict[str, Any]:
+        """Perform a drag operation from start to end coordinates"""
+        return self._request("POST", f"computers/{computer_id}/drag", {
+            "start_x": start_x,
+            "start_y": start_y,
+            "end_x": end_x,
+            "end_y": end_y,
+            "button": button,
+            "duration": duration
+        })
+    
+    def scroll(self, computer_id: str, direction: str, amount: int = 3) -> Dict[str, Any]:
+        return self._request("POST", f"computers/{computer_id}/scroll", {
+            "direction": direction, "amount": amount
+        })
+    
+    def type_text(self, computer_id: str, text: str) -> Dict[str, Any]:
+        return self._request("POST", f"computers/{computer_id}/type", {
+            "text": text
+        })
+    
+    def key_press(self, computer_id: str, key: str) -> Dict[str, Any]:
+        return self._request("POST", f"computers/{computer_id}/key", {
+            "key": key
+        })
+    
+    def get_screenshot(self, computer_id: str) -> Dict[str, Any]:
+        return self._request("GET", f"computers/{computer_id}/screenshot")
+    
+    def execute_bash(self, computer_id: str, command: str) -> Dict[str, Any]:
+        return self._request("POST", f"computers/{computer_id}/bash", {
+            "command": command
+        })
+    
+    def execute_python(self, computer_id: str, code: str, timeout: int = 10) -> Dict[str, Any]:
+        """Execute Python code on the computer"""
+        return self._request("POST", f"computers/{computer_id}/exec", {
+            "code": code,
+            "timeout": timeout
+        })
+    
+    def wait(self, computer_id: str, duration: float) -> Dict[str, Any]:
+        return self._request("POST", f"computers/{computer_id}/wait", {
+            "duration": duration
+        })
+    
+    # Streaming methods
+    def start_stream(self, computer_id: str, connection_name: str) -> Dict[str, Any]:
+        """Start streaming to a configured RTMP connection"""
+        return self._request("POST", f"computers/{computer_id}/stream/start", {
+            "connection_name": connection_name
+        })
+    
+    def stop_stream(self, computer_id: str) -> Dict[str, Any]:
+        """Stop the active stream"""
+        return self._request("POST", f"computers/{computer_id}/stream/stop")
+    
+    def get_stream_status(self, computer_id: str) -> Dict[str, Any]:
+        """Get current stream status"""
+        return self._request("GET", f"computers/{computer_id}/stream/status")

orgo/computer.py

@@ -0,0 +1,326 @@
+"""Computer class for interacting with Orgo virtual environments"""
+import os as operating_system
+import base64
+import logging
+import uuid
+import io
+from typing import Dict, List, Any, Optional, Callable, Literal, Union
+from PIL import Image
+import requests
+from requests.exceptions import RequestException
+
+from .api.client import ApiClient
+from .prompt import get_provider
+
+logger = logging.getLogger(__name__)
+
+class Computer:
+    def __init__(self, 
+                 project: Optional[Union[str, 'Project']] = None,
+                 name: Optional[str] = None,
+                 computer_id: Optional[str] = None,
+                 api_key: Optional[str] = None, 
+                 base_api_url: Optional[str] = None,
+                 ram: Optional[Literal[1, 2, 4, 8, 16, 32, 64]] = None,
+                 memory: Optional[Literal[1, 2, 4, 8, 16, 32, 64]] = None,
+                 cpu: Optional[Literal[1, 2, 4, 8, 16]] = None,
+                 os: Optional[Literal["linux", "windows"]] = None,
+                 gpu: Optional[Literal["none", "a10", "l40s", "a100-40gb", "a100-80gb"]] = None):
+        """
+        Initialize an Orgo virtual computer.
+        
+        Args:
+            project: Project name (str) or Project instance. If not provided, creates a new project.
+            name: Computer name within the project (optional, auto-generated if not provided)
+            computer_id: Existing computer ID to connect to (optional)
+            api_key: Orgo API key (defaults to ORGO_API_KEY env var)
+            base_api_url: Custom API URL (optional)
+            ram/memory: RAM in GB (1, 2, 4, 8, 16, 32, or 64) - only used when creating
+            cpu: CPU cores (1, 2, 4, 8, or 16) - only used when creating
+            os: Operating system ("linux" or "windows") - only used when creating
+            gpu: GPU type - only used when creating
+        
+        Examples:
+            # Create computer in new project
+            computer = Computer(ram=4, cpu=2)
+            
+            # Create computer in existing project
+            computer = Computer(project="manus", ram=4, cpu=2)
+            
+            # Connect to existing computer by ID
+            computer = Computer(computer_id="11c4fd46-e069-4c32-be65-f82d9f87b9b8")
+        """
+        self.api_key = api_key or operating_system.environ.get("ORGO_API_KEY")
+        self.base_api_url = base_api_url
+        self.api = ApiClient(self.api_key, self.base_api_url)
+        
+        # Handle memory parameter as an alias for ram
+        if ram is None and memory is not None:
+            ram = memory
+        
+        # Store configuration
+        self.os = os or "linux"
+        self.ram = ram or 2
+        self.cpu = cpu or 2
+        self.gpu = gpu or "none"
+        
+        if computer_id:
+            # Just store the computer ID, no API call needed
+            self.computer_id = computer_id
+            self.name = name
+            self.project_id = None
+            self.project_name = None
+            logger.info(f"Connected to computer ID: {self.computer_id}")
+        elif project:
+            # Work with specified project
+            if isinstance(project, str):
+                # Project name provided
+                self.project_name = project
+                self._initialize_with_project_name(project, name)
+            else:
+                # Project instance provided
+                from .project import Project as ProjectClass
+                if isinstance(project, ProjectClass):
+                    self.project_name = project.name
+                    self.project_id = project.id
+                    self._initialize_with_project_instance(project, name)
+                else:
+                    raise ValueError("project must be a string (project name) or Project instance")
+        else:
+            # No project specified, create a new one
+            self._create_new_project_and_computer(name)
+    
+    def _initialize_with_project_name(self, project_name: str, computer_name: Optional[str]):
+        """Initialize with a project name (create project if needed)"""
+        try:
+            # Try to get existing project
+            project = self.api.get_project_by_name(project_name)
+            self.project_id = project.get("id")
+            
+            # Check for existing computers
+            computers = self.api.list_computers(self.project_id)
+            
+            if computer_name:
+                # Look for specific computer
+                existing = next((c for c in computers if c.get("name") == computer_name), None)
+                if existing:
+                    self._connect_to_existing_computer(existing)
+                else:
+                    # Create new computer with specified name
+                    self._create_computer(self.project_id, computer_name)
+            elif computers:
+                # No name specified, use first available computer
+                self._connect_to_existing_computer(computers[0])
+            else:
+                # No computers exist, create new one
+                self._create_computer(self.project_id, computer_name)
+                
+        except Exception:
+            # Project doesn't exist, create it
+            logger.info(f"Project {project_name} not found, creating new project")
+            project = self.api.create_project(project_name)
+            self.project_id = project.get("id")
+            self._create_computer(self.project_id, computer_name)
+    
+    def _initialize_with_project_instance(self, project: 'Project', computer_name: Optional[str]):
+        """Initialize with a Project instance"""
+        computers = project.list_computers()
+        
+        if computer_name:
+            # Look for specific computer
+            existing = next((c for c in computers if c.get("name") == computer_name), None)
+            if existing:
+                self._connect_to_existing_computer(existing)
+            else:
+                # Create new computer with specified name
+                self._create_computer(project.id, computer_name)
+        elif computers:
+            # No name specified, use first available computer
+            self._connect_to_existing_computer(computers[0])
+        else:
+            # No computers exist, create new one
+            self._create_computer(project.id, computer_name)
+    
+    def _create_new_project_and_computer(self, computer_name: Optional[str]):
+        """Create a new project and computer"""
+        # Generate a unique project name
+        project_name = f"project-{uuid.uuid4().hex[:8]}"
+        
+        # Create the project
+        project = self.api.create_project(project_name)
+        self.project_id = project.get("id")
+        self.project_name = project_name
+        
+        # Create a computer in the new project
+        self._create_computer(self.project_id, computer_name)
+    
+    def _connect_to_existing_computer(self, computer_info: Dict[str, Any]):
+        """Connect to an existing computer"""
+        self.computer_id = computer_info.get("id")
+        self.name = computer_info.get("name")
+        logger.info(f"Connected to existing computer {self.name} (ID: {self.computer_id})")
+    
+    def _create_computer(self, project_id: str, computer_name: Optional[str]):
+        """Create a new computer in the project"""
+        # Generate name if not provided
+        if not computer_name:
+            computer_name = f"desktop-{uuid.uuid4().hex[:8]}"
+        
+        self.name = computer_name
+        
+        # Validate parameters
+        if self.ram not in [1, 2, 4, 8, 16, 32, 64]:
+            raise ValueError("ram must be one of: 1, 2, 4, 8, 16, 32, 64 GB")
+        if self.cpu not in [1, 2, 4, 8, 16]:
+            raise ValueError("cpu must be one of: 1, 2, 4, 8, 16 cores")
+        if self.os not in ["linux", "windows"]:
+            raise ValueError("os must be either 'linux' or 'windows'")
+        if self.gpu not in ["none", "a10", "l40s", "a100-40gb", "a100-80gb"]:
+            raise ValueError("gpu must be one of: 'none', 'a10', 'l40s', 'a100-40gb', 'a100-80gb'")
+        
+        computer = self.api.create_computer(
+            project_id=project_id,
+            computer_name=computer_name,
+            os=self.os,
+            ram=self.ram,
+            cpu=self.cpu,
+            gpu=self.gpu
+        )
+        self.computer_id = computer.get("id")
+        logger.info(f"Created new computer {self.name} (ID: {self.computer_id})")
+    
+    def status(self) -> Dict[str, Any]:
+        """Get current computer status"""
+        return self.api.get_computer(self.computer_id)
+    
+    def restart(self) -> Dict[str, Any]:
+        """Restart the computer"""
+        return self.api.restart_computer(self.computer_id)
+    
+    def destroy(self) -> Dict[str, Any]:
+        """Terminate and delete the computer instance"""
+        return self.api.delete_computer(self.computer_id)
+    
+    # Navigation methods
+    def left_click(self, x: int, y: int) -> Dict[str, Any]:
+        """Perform left mouse click at specified coordinates"""
+        return self.api.left_click(self.computer_id, x, y)
+    
+    def right_click(self, x: int, y: int) -> Dict[str, Any]:
+        """Perform right mouse click at specified coordinates"""
+        return self.api.right_click(self.computer_id, x, y)
+    
+    def double_click(self, x: int, y: int) -> Dict[str, Any]:
+        """Perform double click at specified coordinates"""
+        return self.api.double_click(self.computer_id, x, y)
+    
+    def drag(self, start_x: int, start_y: int, end_x: int, end_y: int, 
+             button: str = "left", duration: float = 0.5) -> Dict[str, Any]:
+        """Perform a smooth drag operation from start to end coordinates"""
+        return self.api.drag(self.computer_id, start_x, start_y, end_x, end_y, button, duration)
+    
+    def scroll(self, direction: str = "down", amount: int = 3) -> Dict[str, Any]:
+        """Scroll in specified direction and amount"""
+        return self.api.scroll(self.computer_id, direction, amount)
+    
+    # Input methods
+    def type(self, text: str) -> Dict[str, Any]:
+        """Type the specified text"""
+        return self.api.type_text(self.computer_id, text)
+    
+    def key(self, key: str) -> Dict[str, Any]:
+        """Press a key or key combination (e.g., "Enter", "ctrl+c")"""
+        return self.api.key_press(self.computer_id, key)
+    
+    # View methods
+    def screenshot(self) -> Image.Image:
+        """Capture screenshot and return as PIL Image"""
+        response = self.api.get_screenshot(self.computer_id)
+        image_data = response.get("image", "")
+        
+        if image_data.startswith(('http://', 'https://')):
+            img_response = requests.get(image_data)
+            img_response.raise_for_status()
+            return Image.open(io.BytesIO(img_response.content))
+        else:
+            img_data = base64.b64decode(image_data)
+            return Image.open(io.BytesIO(img_data))
+    
+    def screenshot_base64(self) -> str:
+        """Capture screenshot and return as base64 string"""
+        response = self.api.get_screenshot(self.computer_id)
+        image_data = response.get("image", "")
+        
+        if image_data.startswith(('http://', 'https://')):
+            img_response = requests.get(image_data)
+            img_response.raise_for_status()
+            return base64.b64encode(img_response.content).decode('utf-8')
+        else:
+            return image_data
+    
+    # Execution methods
+    def bash(self, command: str) -> str:
+        """Execute a bash command and return output"""
+        response = self.api.execute_bash(self.computer_id, command)
+        return response.get("output", "")
+    
+    def exec(self, code: str, timeout: int = 10) -> Dict[str, Any]:
+        """Execute Python code on the remote computer"""
+        response = self.api.execute_python(self.computer_id, code, timeout)
+        return response
+    
+    def wait(self, seconds: float) -> Dict[str, Any]:
+        """Wait for specified number of seconds"""
+        return self.api.wait(self.computer_id, seconds)
+    
+    # Streaming methods
+    def start_stream(self, connection: str) -> Dict[str, Any]:
+        """Start streaming the computer screen to an RTMP server"""
+        return self.api.start_stream(self.computer_id, connection)
+    
+    def stop_stream(self) -> Dict[str, Any]:
+        """Stop the active stream"""
+        return self.api.stop_stream(self.computer_id)
+    
+    def stream_status(self) -> Dict[str, Any]:
+        """Get the current streaming status"""
+        return self.api.get_stream_status(self.computer_id)
+    
+    # AI control method
+    def prompt(self, 
+               instruction: str,
+               provider: str = "anthropic",
+               model: str = "claude-3-7-sonnet-20250219",
+               display_width: int = 1024,
+               display_height: int = 768,
+               callback: Optional[Callable[[str, Any], None]] = None,
+               thinking_enabled: bool = False,
+               thinking_budget: int = 1024,
+               max_tokens: int = 4096,
+               max_iterations: int = 20,
+               max_saved_screenshots: int = 5,
+               api_key: Optional[str] = None) -> List[Dict[str, Any]]:
+        """Control the computer with natural language instructions using an AI assistant"""
+        provider_instance = get_provider(provider)
+        
+        return provider_instance.execute(
+            computer_id=self.computer_id,
+            instruction=instruction,
+            callback=callback,
+            api_key=api_key,
+            model=model,
+            display_width=display_width,
+            display_height=display_height,
+            thinking_enabled=thinking_enabled,
+            thinking_budget=thinking_budget,
+            max_tokens=max_tokens,
+            max_iterations=max_iterations,
+            max_saved_screenshots=max_saved_screenshots,
+            orgo_api_key=self.api_key,
+            orgo_base_url=self.base_api_url
+        )
+    
+    def __repr__(self):
+        project_str = f", project='{self.project_name}'" if hasattr(self, 'project_name') and self.project_name else ""
+        name_str = f"name='{self.name}'" if hasattr(self, 'name') and self.name else f"id='{self.computer_id}'"
+        return f"Computer({name_str}{project_str})"

orgo/project.py

@@ -0,0 +1,87 @@
+"""Project class for managing Orgo projects"""
+import os as operating_system  # Renamed to avoid any potential conflicts
+import uuid
+from typing import Dict, List, Any, Optional
+
+from .api.client import ApiClient
+
+class Project:
+    def __init__(self, 
+                 name: Optional[str] = None,
+                 api_key: Optional[str] = None,
+                 base_api_url: Optional[str] = None):
+        """
+        Initialize an Orgo project.
+        
+        Args:
+            name: Project name. If exists, connects to it. If not, creates it.
+            api_key: Orgo API key (defaults to ORGO_API_KEY env var)
+            base_api_url: Custom API URL (optional)
+        """
+        self.api_key = api_key or operating_system.environ.get("ORGO_API_KEY")
+        self.base_api_url = base_api_url
+        self.api = ApiClient(self.api_key, self.base_api_url)
+        
+        if name:
+            self.name = name
+        else:
+            # Generate a unique name if not provided
+            self.name = f"project-{uuid.uuid4().hex[:8]}"
+        
+        # Try to get existing project or create new one
+        self._initialize_project()
+    
+    def _initialize_project(self):
+        """Get existing project or create new one"""
+        try:
+            # Try to get existing project
+            project = self.api.get_project_by_name(self.name)
+            self.id = project.get("id")
+            self._info = project
+        except Exception:
+            # Project doesn't exist, create it
+            project = self.api.create_project(self.name)
+            self.id = project.get("id")
+            self._info = project
+    
+    def status(self) -> Dict[str, Any]:
+        """Get project status"""
+        return self.api.get_project(self.id)
+    
+    def start(self) -> Dict[str, Any]:
+        """Start all computers in the project"""
+        return self.api.start_project(self.id)
+    
+    def stop(self) -> Dict[str, Any]:
+        """Stop all computers in the project"""
+        return self.api.stop_project(self.id)
+    
+    def restart(self) -> Dict[str, Any]:
+        """Restart all computers in the project"""
+        return self.api.restart_project(self.id)
+    
+    def destroy(self) -> Dict[str, Any]:
+        """Delete the project and all its computers"""
+        return self.api.delete_project(self.id)
+    
+    def list_computers(self) -> List[Dict[str, Any]]:
+        """List all computers in this project"""
+        return self.api.list_computers(self.name)
+    
+    def get_computer(self, computer_name: str = None) -> Optional[Dict[str, Any]]:
+        """Get a specific computer in this project by name, or the first one if no name specified"""
+        computers = self.list_computers()
+        if not computers:
+            return None
+        
+        if computer_name:
+            for computer in computers:
+                if computer.get("name") == computer_name:
+                    return computer
+            return None
+        else:
+            # Return first computer if no name specified
+            return computers[0]
+    
+    def __repr__(self):
+        return f"Project(name='{self.name}', id='{self.id}')"

orgo/prompt.py

@@ -0,0 +1,452 @@
+# src/orgo/prompt.py
+"""
+Prompt module for interacting with virtual computers using AI models.
+"""
+
+import os
+import base64
+from typing import Dict, List, Any, Optional, Callable, Union, Protocol
+
+
+class PromptProvider(Protocol):
+    """Protocol defining the interface for prompt providers."""
+    
+    def execute(self, 
+                computer_id: str,
+                instruction: str,
+                callback: Optional[Callable[[str, Any], None]] = None,
+                **kwargs) -> List[Dict[str, Any]]:
+        """
+        Execute a prompt to control the computer.
+        
+        Args:
+            computer_id: ID of the computer to control
+            instruction: User instruction
+            callback: Optional progress callback function
+            **kwargs: Additional provider-specific parameters
+            
+        Returns:
+            List of messages from the conversation
+        """
+        ...
+
+
+class AnthropicProvider:
+    """Anthropic Claude-based prompt provider."""
+    
+    def __init__(self):
+        """Initialize the Anthropic provider."""
+        try:
+            import anthropic
+            self.anthropic = anthropic
+        except ImportError:
+            raise ImportError(
+                "Anthropic SDK not installed. Please install with 'pip install anthropic'"
+            )
+    
+    def execute(self,
+                computer_id: str,
+                instruction: str,
+                callback: Optional[Callable[[str, Any], None]] = None,
+                api_key: Optional[str] = None,
+                model: str = "claude-3-7-sonnet-20250219",
+                display_width: int = 1024,
+                display_height: int = 768,
+                orgo_api_key: Optional[str] = None,
+                orgo_base_url: Optional[str] = None,
+                max_saved_screenshots: int = 2,
+                **kwargs) -> List[Dict[str, Any]]:
+        """
+        Execute a prompt using Anthropic's Claude.
+        
+        Args:
+            computer_id: ID of the computer to control
+            instruction: User instruction
+            callback: Optional progress callback
+            api_key: Anthropic API key
+            model: Model to use
+            display_width: Display width in pixels
+            display_height: Display height in pixels
+            orgo_api_key: API key for Orgo (passed to ApiClient)
+            orgo_base_url: Base URL for Orgo API (passed to ApiClient)
+            max_saved_screenshots: Maximum number of screenshots to maintain in conversation history
+            **kwargs: Additional parameters to pass to the Anthropic API
+            
+        Returns:
+            List of messages from the conversation
+        """
+        # Get API key from kwargs, env var, or raise error
+        api_key = api_key or os.environ.get("ANTHROPIC_API_KEY")
+        if not api_key:
+            raise ValueError("No Anthropic API key provided. Set ANTHROPIC_API_KEY environment variable or pass api_key.")
+        
+        # Initialize the client
+        client = self.anthropic.Anthropic(api_key=api_key)
+        
+        # Prepare the messages
+        messages = [{"role": "user", "content": instruction}]
+        
+        # Set up the system prompt
+        system_prompt = f"""You are Claude, an AI assistant that controls a virtual Ubuntu computer with internet access.
+
+<SYSTEM_CAPABILITY>
+* You are utilising an Ubuntu virtual machine with a display resolution of {display_width}x{display_height}.
+* You can take screenshots to see the current state and control the computer by clicking, typing, pressing keys, and scrolling.
+* The virtual environment is an Ubuntu system with standard applications.
+* Always start by taking a screenshot to see the current state before performing any actions.
+</SYSTEM_CAPABILITY>
+
+<UBUNTU_DESKTOP_GUIDELINES>
+* CRITICAL INSTRUCTION: When opening applications or files on the Ubuntu desktop, you MUST USE DOUBLE-CLICK rather than single-click.
+* Single-click only selects desktop icons but DOES NOT open them. To open desktop icons, you MUST use double-click.
+* Common desktop interactions:
+  - Desktop icons: DOUBLE-CLICK to open applications and folders
+  - Menu items: SINGLE-CLICK to select options
+  - Taskbar icons: SINGLE-CLICK to open applications
+  - Window buttons: SINGLE-CLICK to use close, minimize, maximize buttons
+  - File browser items: DOUBLE-CLICK to open folders and files
+  - When submitting, use the 'Enter' key, not the 'Return' key.
+* If you see an icon on the desktop that you need to open, ALWAYS use the double_click action, never use left_click.
+</UBUNTU_DESKTOP_GUIDELINES>
+
+<SCREENSHOT_GUIDELINES>
+* Be mindful of how many screenshots you take - they consume significant memory.
+* Only take screenshots when you need to see the current state of the screen.
+* Try to batch multiple actions before taking another screenshot.
+* For better performance, limit the number of screenshots you take.
+</SCREENSHOT_GUIDELINES>"""
+        
+        try:
+            # Define the computer tool per Anthropic's documentation
+            tools = [
+                {
+                    "type": "computer_20250124",
+                    "name": "computer",
+                    "display_width_px": display_width,
+                    "display_height_px": display_height,
+                    "display_number": 1
+                }
+            ]
+            
+            # Start the conversation with Claude
+            if callback:
+                callback("status", "Starting conversation with Claude")
+            
+            # Track whether we're in the agent loop
+            iteration = 0
+            max_iterations = kwargs.get("max_iterations", 20)  # Default to 20 iterations max
+            
+            # Create an API client with the proper settings
+            from .api.client import ApiClient
+            api_client = ApiClient(orgo_api_key, orgo_base_url)
+            
+            # Track how many screenshots we've seen so we can prune when needed
+            screenshot_count = 0
+            
+            # Start the agent loop
+            while iteration < max_iterations:
+                iteration += 1
+                
+                # Filter to keep only the N most recent screenshots
+                if screenshot_count > max_saved_screenshots:
+                    self._filter_to_n_most_recent_images(messages, max_saved_screenshots)
+                    screenshot_count = max_saved_screenshots
+                
+                # Create the request parameters
+                request_params = {
+                    "model": model,
+                    "max_tokens": kwargs.get("max_tokens", 4096),
+                    "system": system_prompt,
+                    "messages": messages,
+                    "tools": tools,
+                    "betas": ["computer-use-2025-01-24"],
+                }
+                
+                # Add thinking parameter only if explicitly enabled
+                if kwargs.get("thinking_enabled"):
+                    request_params["thinking"] = {
+                        "type": "enabled", 
+                        "budget_tokens": kwargs.get("thinking_budget", 1024)
+                    }
+                
+                # Create message request to Claude
+                try:
+                    response = client.beta.messages.create(**request_params)
+                except Exception as e:
+                    if "base64" in str(e).lower():
+                        # If we get a base64 error, try again after more aggressively filtering images
+                        if callback:
+                            callback("error", f"Base64 error detected. Attempting recovery...")
+                        
+                        # Remove all but the most recent image and try again
+                        self._filter_to_n_most_recent_images(messages, 1)
+                        response = client.beta.messages.create(**request_params)
+                    else:
+                        # Not a base64 error, re-raise
+                        raise
+                
+                # Extract the content from the response
+                response_content = response.content
+                
+                # Add Claude's response to the conversation history
+                assistant_message = {"role": "assistant", "content": response_content}
+                messages.append(assistant_message)
+                
+                # Notify callback of any text content
+                for block in response_content:
+                    if block.type == "text" and callback:
+                        callback("text", block.text)
+                    elif block.type == "thinking" and callback:
+                        callback("thinking", block.thinking)
+                    elif block.type == "tool_use" and callback:
+                        tool_params = {
+                            "action": block.name.split(".")[-1],
+                            **block.input
+                        }
+                        callback("tool_use", tool_params)
+                
+                # Check if Claude requested any tool actions
+                tool_results = []
+                for block in response_content:
+                    if block.type == "tool_use":
+                        # Execute the tool action
+                        result = self._execute_tool(computer_id, block.input, callback, api_client)
+                        
+                        # Format the result for Claude
+                        tool_result = {
+                            "type": "tool_result",
+                            "tool_use_id": block.id
+                        }
+                        
+                        # Handle image vs text results
+                        if isinstance(result, dict) and "type" in result and result["type"] == "image":
+                            tool_result["content"] = [result]
+                            # Increment screenshot count when we add a new screenshot
+                            if block.input.get("action") == "screenshot":
+                                screenshot_count += 1
+                        else:
+                            tool_result["content"] = [{"type": "text", "text": str(result)}]
+                        
+                        tool_results.append(tool_result)
+                
+                # If no tools were used, Claude is done - return the messages
+                if not tool_results:
+                    if callback:
+                        callback("status", "Task completed")
+                    return messages
+                
+                # Add tool results to messages for the next iteration
+                messages.append({"role": "user", "content": tool_results})
+            
+            # We've reached the maximum iteration limit
+            if callback:
+                callback("status", f"Reached maximum iterations ({max_iterations})")
+            
+            return messages
+            
+        except Exception as e:
+            if callback:
+                callback("error", str(e))
+            raise
+    
+    def _filter_to_n_most_recent_images(self, messages: List[Dict[str, Any]], max_images: int):
+        """
+        Keep only the N most recent images in the conversation history.
+        
+        Args:
+            messages: The conversation history
+            max_images: Maximum number of images to keep
+        """
+        # Find all the image blocks in the conversation history
+        image_blocks = []
+        
+        for msg_idx, msg in enumerate(messages):
+            if msg["role"] != "user":
+                continue
+                
+            content = msg.get("content", [])
+            if not isinstance(content, list):
+                continue
+                
+            for content_idx, block in enumerate(content):
+                if not isinstance(block, dict):
+                    continue
+                    
+                if block.get("type") != "tool_result":
+                    continue
+                
+                block_content = block.get("content", [])
+                for content_item_idx, content_item in enumerate(block_content):
+                    if not isinstance(content_item, dict):
+                        continue
+                        
+                    if content_item.get("type") == "image" and "source" in content_item:
+                        image_blocks.append({
+                            "msg_idx": msg_idx,
+                            "content_idx": content_idx,
+                            "block": block,
+                            "content_item_idx": content_item_idx,
+                            "content_item": content_item
+                        })
+        
+        # If we have more images than our limit, remove the oldest ones
+        if len(image_blocks) > max_images:
+            # Keep only the most recent ones (which are at the end of the list)
+            images_to_remove = image_blocks[:-max_images]
+            
+            for img_block in images_to_remove:
+                content_item = img_block["content_item"]
+                if "source" in content_item and "data" in content_item["source"]:
+                    # Replace with a minimal valid base64 image (1x1 transparent PNG)
+                    content_item["source"]["data"] = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg=="
+                    content_item["source"]["media_type"] = "image/png"
+    
+    def _execute_tool(self, 
+                      computer_id: str,
+                      params: Dict[str, Any], 
+                      callback: Optional[Callable[[str, Any], None]] = None,
+                      api_client = None) -> Union[str, Dict[str, Any]]:
+        """Execute a tool action via the API client."""
+        action = params.get("action")
+        
+        if callback:
+            callback("tool_executing", {"action": action, "params": params})
+        
+        try:
+            # Use the provided API client or create a new one
+            if api_client is None:
+                # Import here to avoid circular imports
+                from .api.client import ApiClient
+                api_client = ApiClient()
+            
+            # Map actions to API methods
+            if action == "screenshot":
+                response = api_client.get_screenshot(computer_id)
+                if callback:
+                    callback("tool_result", {"type": "image", "action": "screenshot"})
+                
+                # The API now returns a URL instead of base64 data
+                # We need to fetch the image from the URL and convert it to base64
+                image_url = response.get("image", "")
+                
+                if not image_url:
+                    raise ValueError("No image URL received from API")
+                
+                # Fetch the image from the URL
+                import requests
+                img_response = requests.get(image_url)
+                img_response.raise_for_status()
+                
+                # Convert to base64
+                image_base64 = base64.b64encode(img_response.content).decode('utf-8')
+                
+                return {
+                    "type": "image",
+                    "source": {
+                        "type": "base64",
+                        "media_type": "image/jpeg",
+                        "data": image_base64
+                    }
+                }
+                
+            elif action == "left_click":
+                if not params.get("coordinate"):
+                    raise ValueError("Coordinates required for left click")
+                x, y = params["coordinate"]
+                api_client.left_click(computer_id, x, y)
+                if callback:
+                    callback("tool_result", {"action": "left_click", "x": x, "y": y})
+                return f"Left-clicked at ({x}, {y})"
+                
+            elif action == "right_click":
+                if not params.get("coordinate"):
+                    raise ValueError("Coordinates required for right click")
+                x, y = params["coordinate"]
+                api_client.right_click(computer_id, x, y)
+                if callback:
+                    callback("tool_result", {"action": "right_click", "x": x, "y": y})
+                return f"Right-clicked at ({x}, {y})"
+                
+            elif action == "double_click":
+                if not params.get("coordinate"):
+                    raise ValueError("Coordinates required for double click")
+                x, y = params["coordinate"]
+                api_client.double_click(computer_id, x, y)
+                if callback:
+                    callback("tool_result", {"action": "double_click", "x": x, "y": y})
+                return f"Double-clicked at ({x}, {y})"
+                
+            elif action == "type":
+                if not params.get("text"):
+                    raise ValueError("Text required for typing")
+                text = params["text"]
+                api_client.type_text(computer_id, text)
+                if callback:
+                    callback("tool_result", {"action": "type", "text": text})
+                return f"Typed: \"{text}\""
+                
+            elif action == "key":
+                if not params.get("text"):
+                    raise ValueError("Key required for key press")
+                key = params["text"]
+                # Handle the 'return' key as 'enter' when needed
+                if key.lower() == "return":
+                    key = "enter"
+                api_client.key_press(computer_id, key)
+                if callback:
+                    callback("tool_result", {"action": "key", "key": key})
+                return f"Pressed key: {key}"
+                
+            elif action == "scroll":
+                if not params.get("scroll_direction") or params.get("scroll_amount") is None:
+                    raise ValueError("Direction and amount required for scrolling")
+                direction = params["scroll_direction"]
+                amount = params["scroll_amount"]
+                api_client.scroll(computer_id, direction, amount)
+                if callback:
+                    callback("tool_result", {"action": "scroll", "direction": direction, "amount": amount})
+                return f"Scrolled {direction} by {amount}"
+                
+            elif action == "wait":
+                duration = params.get("duration", 1)
+                api_client.wait(computer_id, duration)
+                if callback:
+                    callback("tool_result", {"action": "wait", "duration": duration})
+                return f"Waited for {duration} second(s)"
+                
+            else:
+                error_msg = f"Unsupported action: {action}"
+                if callback:
+                    callback("error", error_msg)
+                raise ValueError(error_msg)
+                
+        except Exception as e:
+            error_msg = f"Error executing {action}: {str(e)}"
+            if callback:
+                callback("error", error_msg)
+            return f"Error: {error_msg}"
+
+
+# Default provider mapping
+PROVIDER_MAPPING = {
+    "anthropic": AnthropicProvider,
+    # Add more providers here as needed, e.g.:
+    # "openai": OpenAIProvider,
+    # "fireworks": FireworksProvider,
+}
+
+
+def get_provider(provider_name: str = "anthropic") -> PromptProvider:
+    """
+    Get a prompt provider by name.
+    
+    Args:
+        provider_name: Name of the provider
+        
+    Returns:
+        Provider instance
+    """
+    if provider_name not in PROVIDER_MAPPING:
+        raise ValueError(f"Unknown provider: {provider_name}. Available providers: {', '.join(PROVIDER_MAPPING.keys())}")
+    
+    return PROVIDER_MAPPING[provider_name]()

orgo/utils/__init__.py

@@ -0,0 +1,6 @@
+# src/orgo/utils/__init__.py
+"""Utility functions for Orgo SDK"""
+
+from .auth import get_api_key
+
+__all__ = ["get_api_key"]

orgo/utils/auth.py

@@ -0,0 +1,17 @@
+# src/orgo/utils/auth.py
+"""Authentication utilities for Orgo SDK"""
+
+import os
+from typing import Optional
+
+def get_api_key(api_key: Optional[str] = None) -> str:
+    """Get the Orgo API key from parameters or environment"""
+    key = api_key or os.environ.get("ORGO_API_KEY")
+    
+    if not key:
+        raise ValueError(
+            "API key required. Set ORGO_API_KEY environment variable or pass api_key parameter. "
+            "Get a key at https://www.orgo.ai/start"
+        )
+        
+    return key

orgo-0.0.32.dist-info/METADATA

@@ -0,0 +1,45 @@
+Metadata-Version: 2.4
+Name: orgo
+Version: 0.0.32
+Summary: Computers for AI agents
+Author: Orgo Team
+License: MIT
+Project-URL: Homepage, https://www.orgo.ai
+Project-URL: Documentation, https://docs.orgo.ai
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.25.0
+Requires-Dist: pillow>=8.0.0
+
+# Orgo SDK
+
+Desktop infrastructure for AI agents.
+
+## Install
+
+```bash
+pip install orgo
+```
+
+## Usage
+
+```python
+from orgo import Computer
+
+# Create computer
+computer = Computer()
+
+# Control
+computer.left_click(100, 200)
+computer.type("Hello world")
+computer.key("Enter")
+computer.screenshot()  # Returns PIL Image
+
+# Execute Python code
+computer.exec("import pyautogui; pyautogui.click(512, 384)")
+
+# Cleanup
+computer.shutdown()
+```
+
+Full documentation: [docs.orgo.ai](https://docs.orgo.ai)

orgo-0.0.32.dist-info/RECORD

@@ -0,0 +1,12 @@
+orgo/__init__.py,sha256=aw3BM7-Wy8jk-mvIWRG2gC4-nsc74s6ZFm1U21NyGeM,171
+orgo/computer.py,sha256=np8g67-ASCci3EmtQweCpOjDzeUMkXfAY9wve9s7tCc,14268
+orgo/project.py,sha256=uVDFa8iyn5OaHzTzjGQhxnF_nVzwkqkqUShiV3M0AWU,3150
+orgo/prompt.py,sha256=ynblwXPTDp_aF1MbGBsY0PIEr9naklDaKFcfSE_EZ6E,19781
+orgo/api/__init__.py,sha256=9Tzb_OPJ5DH7Cg7OrHzpZZUT4ip05alpa9RLDYmnId8,113
+orgo/api/client.py,sha256=apny7V3IYJTyDwn5utukzyECLWT65oo-1EmFRwHL--E,7544
+orgo/utils/__init__.py,sha256=W4G_nwGBf_7jy0w_mfcrkllurYHSRU4B5cMTVYH_uCc,123
+orgo/utils/auth.py,sha256=tPLBJY-6gdBQWLUjUbwIwxHphC3KoRT_XgP3Iykw3Mw,509
+orgo-0.0.32.dist-info/METADATA,sha256=w3RNXo5BW2YlXUgUb1TzkXaJ50RpkPd0Zd-vOllwx_A,822
+orgo-0.0.32.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+orgo-0.0.32.dist-info/top_level.txt,sha256=q0rYtFji8GbYuhFW8A5Ab9e0j27761IKPhnL0E9xow4,5
+orgo-0.0.32.dist-info/RECORD,,

orgo-0.0.32.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

orgo-0.0.32.dist-info/top_level.txt

@@ -0,0 +1 @@
+orgo