orgo 0.0.37__py3-none-any.whl → 0.0.39__py3-none-any.whl

orgo/computer.py

@@ -4,7 +4,7 @@ Orgo Computer - Control virtual computers with AI.
 Usage:
     from orgo import Computer
     
-    computer = Computer(computer_id="your-computer-id")
+    computer = Computer(project="your-project")
     computer.prompt("Open Firefox and search for AI news")
 """
 
@@ -13,6 +13,7 @@ import base64
 import logging
 import uuid
 import io
+import random
 from typing import Dict, List, Any, Optional, Callable, Literal, Union
 from PIL import Image
 import requests
@@ -24,16 +25,39 @@ from .prompt import get_provider
 logger = logging.getLogger(__name__)
 
 
+def _generate_computer_name() -> str:
+    """Generate a random computer name like 'computer-1568'"""
+    return f"computer-{random.randint(1000, 9999)}"
+
+
+def _print_success(message: str):
+    """Print a success message with nice formatting"""
+    print(f"✓ {message}")
+
+
+def _print_error(message: str):
+    """Print an error message with nice formatting"""
+    print(f"✗ {message}")
+
+
+def _print_info(message: str):
+    """Print an info message with nice formatting"""
+    print(f"→ {message}")
+
+
 class Computer:
     """
     Control an Orgo virtual computer.
     
     Examples:
-        # Connect to existing computer
-        computer = Computer(computer_id="abc123")
+        # Create computer in new/existing project
+        computer = Computer(project="my-project")
         
-        # Create new computer in project
-        computer = Computer(project="my-project", ram=4, cpu=2)
+        # Create with specific name
+        computer = Computer(project="my-project", name="dev-machine")
+        
+        # Connect to existing computer by ID
+        computer = Computer(computer_id="abc123")
         
         # AI control (uses Orgo by default)
         computer.prompt("Open Firefox")
@@ -53,14 +77,15 @@ class Computer:
                  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,
-                 image: Optional[Union[str, Any]] = None):
+                 image: Optional[Union[str, Any]] = None,
+                 verbose: bool = True):
         """
         Initialize an Orgo virtual computer.
         
         Args:
-            computer_id: Connect to existing computer by ID
-            project: Project name or Project instance
+            project: Project name or Project instance (creates if doesn't exist)
             name: Computer name (auto-generated if not provided)
+            computer_id: Connect to existing computer by ID
             api_key: Orgo API key (defaults to ORGO_API_KEY env var)
             base_api_url: Custom API URL
             ram/memory: RAM in GB (1, 2, 4, 8, 16, 32, 64)
@@ -68,10 +93,12 @@ class Computer:
             os: "linux" or "windows"
             gpu: "none", "a10", "l40s", "a100-40gb", "a100-80gb"
             image: Custom image reference or Forge object
+            verbose: Show console output (default: True)
         """
         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)
+        self.verbose = verbose
         
         if ram is None and memory is not None:
             ram = memory
@@ -83,7 +110,8 @@ class Computer:
         self.image = image
         
         if hasattr(self.image, 'build') and callable(self.image.build):
-            logger.info("Building image from Forge object...")
+            if self.verbose:
+                _print_info("Building image from Forge object...")
             self.image = self.image.build()
         
         if computer_id:
@@ -91,7 +119,8 @@ class Computer:
             self.name = name
             self.project_id = None
             self.project_name = None
-            logger.info(f"Connected to computer: {self.computer_id}")
+            if self.verbose:
+                _print_success(f"Connected to computer: {self.computer_id}")
         elif project:
             if isinstance(project, str):
                 self.project_name = project
@@ -112,60 +141,69 @@ class Computer:
     # =========================================================================
     
     def _initialize_with_project_name(self, project_name: str, computer_name: Optional[str]):
+        """Initialize computer with 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")
-            computers = self.api.list_computers(self.project_id)
             
-            if computer_name:
-                existing = next((c for c in computers if c.get("name") == computer_name), None)
-                if existing:
-                    self._connect_to_existing_computer(existing)
-                else:
-                    self._create_computer(self.project_id, computer_name)
-            elif computers:
-                self._connect_to_existing_computer(computers[0])
-            else:
-                self._create_computer(self.project_id, computer_name)
+            # If no computer name specified, generate one
+            if not computer_name:
+                computer_name = _generate_computer_name()
+            
+            # Create the computer in this project
+            self._create_computer(self.project_id, computer_name, project_name)
+            
         except Exception:
-            logger.info(f"Creating new project: {project_name}")
+            # Project doesn't exist, create it
+            if self.verbose:
+                _print_info(f"Creating project: {project_name}")
             project = self.api.create_project(project_name)
             self.project_id = project.get("id")
-            self._create_computer(self.project_id, computer_name)
+            
+            # Generate name if not specified
+            if not computer_name:
+                computer_name = _generate_computer_name()
+            
+            self._create_computer(self.project_id, computer_name, project_name)
     
     def _initialize_with_project_instance(self, project: 'Project', computer_name: Optional[str]):
-        computers = project.list_computers()
+        """Initialize computer with Project instance"""
+        # Generate name if not specified
+        if not computer_name:
+            computer_name = _generate_computer_name()
         
-        if computer_name:
-            existing = next((c for c in computers if c.get("name") == computer_name), None)
-            if existing:
-                self._connect_to_existing_computer(existing)
-            else:
-                self._create_computer(project.id, computer_name)
-        elif computers:
-            self._connect_to_existing_computer(computers[0])
-        else:
-            self._create_computer(project.id, computer_name)
+        self._create_computer(project.id, computer_name, project.name)
     
     def _create_new_project_and_computer(self, computer_name: Optional[str]):
+        """Create a new project and computer when no project specified"""
         project_name = f"project-{uuid.uuid4().hex[:8]}"
+        
+        if self.verbose:
+            _print_info(f"Creating project: {project_name}")
+        
         project = self.api.create_project(project_name)
         self.project_id = project.get("id")
         self.project_name = project_name
-        self._create_computer(self.project_id, computer_name)
+        
+        # Generate name if not specified
+        if not computer_name:
+            computer_name = _generate_computer_name()
+        
+        self._create_computer(self.project_id, computer_name, project_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: {self.name} ({self.computer_id})")
+        if self.verbose:
+            _print_success(f"Connected to: {self.name} ({self.computer_id})")
     
-    def _create_computer(self, project_id: str, computer_name: Optional[str]):
-        if not computer_name:
-            computer_name = f"desktop-{uuid.uuid4().hex[:8]}"
-        
+    def _create_computer(self, project_id: str, computer_name: str, project_name: str):
+        """Create a new computer with beautiful console output"""
         self.name = computer_name
         
-        # Validate
+        # Validate parameters
         if self.ram not in [1, 2, 4, 8, 16, 32, 64]:
             raise ValueError("ram must be: 1, 2, 4, 8, 16, 32, or 64 GB")
         if self.cpu not in [1, 2, 4, 8, 16]:
@@ -175,7 +213,7 @@ class Computer:
         if self.gpu not in ["none", "a10", "l40s", "a100-40gb", "a100-80gb"]:
             raise ValueError("gpu must be: 'none', 'a10', 'l40s', 'a100-40gb', or 'a100-80gb'")
         
-        # Resolve image
+        # Resolve image if needed
         image_ref = self.image
         if image_ref and isinstance(image_ref, str) and not image_ref.startswith("registry.fly.io"):
             try:
@@ -187,19 +225,34 @@ class Computer:
                     if resolved:
                         image_ref = resolved
             except Exception as e:
-                logger.warning(f"Failed to resolve image: {e}")
+                if self.verbose:
+                    logger.warning(f"Failed to resolve image: {e}")
         
-        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,
-            image=image_ref
-        )
-        self.computer_id = computer.get("id")
-        logger.info(f"Created: {self.name} ({self.computer_id})")
+        # Create the computer
+        try:
+            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,
+                image=image_ref
+            )
+            self.computer_id = computer.get("id")
+            
+            # Beautiful success message
+            if self.verbose:
+                _print_success(
+                    f"Computer [{self.name}] successfully created under workspace [{project_name}]"
+                )
+                _print_info(f"ID: {self.computer_id}")
+                _print_info(f"View at: https://orgo.ai/workspaces/{self.computer_id}")
+        
+        except Exception as e:
+            if self.verbose:
+                _print_error(f"Failed to create computer: {str(e)}")
+            raise
     
     # =========================================================================
     # Computer Management
@@ -211,11 +264,21 @@ class Computer:
     
     def restart(self) -> Dict[str, Any]:
         """Restart the computer."""
-        return self.api.restart_computer(self.computer_id)
+        if self.verbose:
+            _print_info(f"Restarting computer: {self.name}")
+        result = self.api.restart_computer(self.computer_id)
+        if self.verbose:
+            _print_success("Computer restarted")
+        return result
     
     def destroy(self) -> Dict[str, Any]:
         """Delete the computer."""
-        return self.api.delete_computer(self.computer_id)
+        if self.verbose:
+            _print_info(f"Deleting computer: {self.name}")
+        result = self.api.delete_computer(self.computer_id)
+        if self.verbose:
+            _print_success("Computer deleted")
+        return result
     
     # =========================================================================
     # Mouse Actions

orgo/prompt.py

@@ -122,6 +122,13 @@ class Console:
         timestamp = self._c(Colors.DIM, datetime.now().strftime("%H:%M:%S"))
         print(f"  {timestamp}  {self._c(Colors.RED, '✗')}  {self._c(Colors.RED, message)}")
     
+    def retry(self, attempt: int, max_attempts: int, delay: float):
+        """Print retry message."""
+        if not self.verbose:
+            return
+        timestamp = self._c(Colors.DIM, datetime.now().strftime("%H:%M:%S"))
+        print(f"  {timestamp}  {self._c(Colors.YELLOW, '↻')}  Retry {attempt}/{max_attempts} in {delay:.1f}s")
+    
     def success(self, iterations: int = 0):
         """Print success message."""
         if not self.verbose:
@@ -138,6 +145,20 @@ class Console:
         print()
 
 
+# =============================================================================
+# Exceptions
+# =============================================================================
+
+class ScreenshotError(Exception):
+    """Raised when screenshot capture fails."""
+    pass
+
+
+class TransientVisionError(Exception):
+    """Raised when Claude's vision API temporarily fails."""
+    pass
+
+
 # =============================================================================
 # System Prompt
 # =============================================================================
@@ -535,6 +556,8 @@ class AnthropicProvider:
         thinking_enabled = kwargs.get("thinking_enabled", True)
         thinking_budget = kwargs.get("thinking_budget", 1024)
         max_saved_screenshots = kwargs.get("max_saved_screenshots", 3)
+        screenshot_retry_attempts = kwargs.get("screenshot_retry_attempts", 3)
+        screenshot_retry_delay = kwargs.get("screenshot_retry_delay", 2.0)
         
         # System prompt
         full_system_prompt = get_system_prompt(display_width, display_height, system_prompt)
@@ -581,15 +604,15 @@ class AnthropicProvider:
                     "budget_tokens": thinking_budget
                 }
             
-            # Call Claude
-            try:
-                response = client.beta.messages.create(**request_params)
-            except Exception as e:
-                if "base64" in str(e).lower():
-                    self._prune_screenshots(messages, 1)
-                    response = client.beta.messages.create(**request_params)
-                else:
-                    raise
+            # Call Claude with retry logic
+            response = self._call_claude_with_retry(
+                client=client,
+                request_params=request_params,
+                messages=messages,
+                console=console,
+                max_retries=screenshot_retry_attempts,
+                retry_delay=screenshot_retry_delay
+            )
             
             response_content = response.content
             messages.append({"role": "assistant", "content": response_content})
@@ -627,11 +650,20 @@ class AnthropicProvider:
                     if callback:
                         callback("tool_use", {"action": action, "params": block.input})
             
-            # Execute tools
+            # Execute tools with retry logic
             tool_results = []
             for block in response_content:
                 if block.type == "tool_use":
-                    result = self._execute_tool(computer_id, block.input, orgo_key, orgo_url, callback)
+                    result = self._execute_tool_with_retry(
+                        computer_id=computer_id,
+                        params=block.input,
+                        orgo_key=orgo_key,
+                        orgo_url=orgo_url,
+                        console=console,
+                        callback=callback,
+                        max_retries=screenshot_retry_attempts,
+                        retry_delay=screenshot_retry_delay
+                    )
                     
                     tool_result = {"type": "tool_result", "tool_use_id": block.id}
                     
@@ -653,6 +685,128 @@ class AnthropicProvider:
         console.success(iteration)
         return messages
     
+    def _call_claude_with_retry(
+        self,
+        client: anthropic.Anthropic,
+        request_params: Dict[str, Any],
+        messages: List[Dict[str, Any]],
+        console: Console,
+        max_retries: int = 3,
+        retry_delay: float = 2.0
+    ) -> Any:
+        """Call Claude API with exponential backoff retry logic."""
+        
+        last_error = None
+        
+        for attempt in range(max_retries):
+            try:
+                return client.beta.messages.create(**request_params)
+                
+            except anthropic.BadRequestError as e:
+                error_msg = str(e).lower()
+                
+                # Check for vision/image processing errors
+                if "image" in error_msg or "vision" in error_msg or "could not process" in error_msg:
+                    last_error = TransientVisionError(f"Vision API error: {e}")
+                    
+                    if attempt < max_retries - 1:
+                        delay = retry_delay * (2 ** attempt)  # Exponential backoff: 2s, 4s, 8s
+                        console.retry(attempt + 1, max_retries, delay)
+                        time.sleep(delay)
+                        
+                        # Prune screenshots to reduce payload size
+                        self._prune_screenshots(messages, 1)
+                        request_params["messages"] = messages
+                        continue
+                    else:
+                        raise last_error
+                
+                # Check for base64 errors (fallback from old code)
+                elif "base64" in error_msg:
+                    if attempt < max_retries - 1:
+                        delay = retry_delay * (2 ** attempt)
+                        console.retry(attempt + 1, max_retries, delay)
+                        time.sleep(delay)
+                        
+                        self._prune_screenshots(messages, 1)
+                        request_params["messages"] = messages
+                        continue
+                    else:
+                        raise
+                else:
+                    # Non-retryable error
+                    raise
+                    
+            except (anthropic.APIConnectionError, anthropic.APITimeoutError) as e:
+                # Network errors - retry with backoff
+                last_error = e
+                
+                if attempt < max_retries - 1:
+                    delay = retry_delay * (2 ** attempt)
+                    console.retry(attempt + 1, max_retries, delay)
+                    time.sleep(delay)
+                    continue
+                else:
+                    raise
+            
+            except Exception as e:
+                # Unexpected errors - don't retry
+                raise
+        
+        # Should never reach here, but just in case
+        if last_error:
+            raise last_error
+        raise RuntimeError("Max retries exceeded")
+    
+    def _execute_tool_with_retry(
+        self,
+        computer_id: str,
+        params: Dict,
+        orgo_key: str,
+        orgo_url: str,
+        console: Console,
+        callback: Optional[Callable],
+        max_retries: int = 3,
+        retry_delay: float = 2.0
+    ) -> Any:
+        """Execute tool with retry logic for screenshots."""
+        
+        action = params.get("action")
+        
+        # Only retry screenshots, execute other actions directly
+        if action != "screenshot":
+            return self._execute_tool(computer_id, params, orgo_key, orgo_url, callback)
+        
+        last_error = None
+        
+        for attempt in range(max_retries):
+            try:
+                return self._execute_tool(computer_id, params, orgo_key, orgo_url, callback)
+                
+            except (ScreenshotError, requests.exceptions.RequestException) as e:
+                last_error = e
+                
+                if attempt < max_retries - 1:
+                    delay = retry_delay * (2 ** attempt)  # Exponential backoff
+                    console.retry(attempt + 1, max_retries, delay)
+                    time.sleep(delay)
+                    continue
+                else:
+                    # Return placeholder after all retries exhausted
+                    logger.error(f"Screenshot failed after {max_retries} attempts: {e}")
+                    return "Screenshot captured (degraded quality)"
+            
+            except Exception as e:
+                # Unexpected errors - don't retry
+                raise
+        
+        # Fallback if all retries failed
+        if last_error:
+            logger.error(f"Screenshot failed: {last_error}")
+            return "Screenshot captured (degraded quality)"
+        
+        return "Screenshot captured"
+    
     def _execute_tool(self, computer_id: str, params: Dict, orgo_key: str, orgo_url: str, callback: Optional[Callable]) -> Any:
         """Execute a tool action via Orgo API."""
         
@@ -662,10 +816,10 @@ class AnthropicProvider:
         
         try:
             # =================================================================
-            # SCREENSHOT - GET request
+            # SCREENSHOT - GET request with validation
             # =================================================================
             if action == "screenshot":
-                r = requests.get(f"{base_url}/screenshot", headers=headers)
+                r = requests.get(f"{base_url}/screenshot", headers=headers, timeout=30)
                 r.raise_for_status()
                 
                 data = r.json()
@@ -673,14 +827,21 @@ class AnthropicProvider:
                 
                 if not image_url:
                     logger.error(f"Screenshot API returned no image URL: {data}")
-                    return "Screenshot captured"
+                    raise ScreenshotError("No image URL in response")
                 
-                img_r = requests.get(image_url)
+                # Fetch the actual image
+                img_r = requests.get(image_url, timeout=30)
                 img_r.raise_for_status()
                 
+                # Validate image size
                 if len(img_r.content) < 100:
                     logger.error(f"Screenshot image too small: {len(img_r.content)} bytes")
-                    return "Screenshot captured"
+                    raise ScreenshotError(f"Invalid image size: {len(img_r.content)} bytes")
+                
+                # Validate it's actually an image
+                if not img_r.headers.get('content-type', '').startswith('image/'):
+                    logger.error(f"Invalid content type: {img_r.headers.get('content-type')}")
+                    raise ScreenshotError("Response is not an image")
                 
                 image_b64 = base64.b64encode(img_r.content).decode()
                 
@@ -793,10 +954,16 @@ class AnthropicProvider:
                 return f"Unknown action: {action}"
                 
         except requests.exceptions.RequestException as e:
-            logger.error(f"API request failed for {action}: {e}")
-            return f"Action {action} completed"
+            if action == "screenshot":
+                # Re-raise as ScreenshotError for retry logic
+                raise ScreenshotError(f"Screenshot request failed: {e}") from e
+            else:
+                logger.error(f"API request failed for {action}: {e}")
+                return f"Action {action} completed"
         except Exception as e:
             logger.error(f"Error executing {action}: {e}")
+            if action == "screenshot":
+                raise ScreenshotError(f"Screenshot processing failed: {e}") from e
             return f"Action {action} completed"
     
     def _prune_screenshots(self, messages: List[Dict], keep: int):
@@ -815,6 +982,7 @@ class AnthropicProvider:
                     if isinstance(item, dict) and item.get("type") == "image":
                         images.append(item)
         
+        # Replace older screenshots with 1x1 transparent PNG
         for img in images[:-keep]:
             if "source" in img:
                 img["source"]["data"] = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg=="

{orgo-0.0.37.dist-info → orgo-0.0.39.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orgo
-Version: 0.0.37
+Version: 0.0.39
 Summary: Computers for AI agents
 Author: Orgo Team
 License: MIT

{orgo-0.0.37.dist-info → orgo-0.0.39.dist-info}/RECORD

@@ -1,13 +1,13 @@
 orgo/__init__.py,sha256=7uMYbhVNVUtrH7mCd8Ofll36EIdR92LcVlF7bdKuVR4,206
-orgo/computer.py,sha256=plxLG-N01IsmejEZUurrq1b2R9n-okoFZ4evRfO5oao,16578
+orgo/computer.py,sha256=7yNxlIk7j6yIcYXDF8HQfJU1uHNHvO9lLP4TTVZEuy4,18661
 orgo/forge.py,sha256=Ey_X3tZwlgHPCSBYBIxPInNaERARoDZQ3vxjvOBLn_I,6714
 orgo/project.py,sha256=Abn58FKAL3vety-MzHJDR-G0GFnEDSD_ljTYnXp9e1I,3148
-orgo/prompt.py,sha256=WQEtNwEAP8VSD9bum-Zx3pGvR_sH4OWm2nhmQx4of1Y,32820
+orgo/prompt.py,sha256=EluyrgMLfgQ8C6kR4l_jKhu6mnCuSL14PGYO1AE4FKk,39685
 orgo/api/__init__.py,sha256=9Tzb_OPJ5DH7Cg7OrHzpZZUT4ip05alpa9RLDYmnId8,113
 orgo/api/client.py,sha256=VGdlBCu2gAdDwMZ55n7kQS4R-CFXJjLByXPmRlMLoiY,9097
 orgo/utils/__init__.py,sha256=W4G_nwGBf_7jy0w_mfcrkllurYHSRU4B5cMTVYH_uCc,123
 orgo/utils/auth.py,sha256=tPLBJY-6gdBQWLUjUbwIwxHphC3KoRT_XgP3Iykw3Mw,509
-orgo-0.0.37.dist-info/METADATA,sha256=UcAoDm3Lu_b9_8ifjoRwFKOFSlMVEBObn-N2F0k3pHE,894
-orgo-0.0.37.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-orgo-0.0.37.dist-info/top_level.txt,sha256=q0rYtFji8GbYuhFW8A5Ab9e0j27761IKPhnL0E9xow4,5
-orgo-0.0.37.dist-info/RECORD,,
+orgo-0.0.39.dist-info/METADATA,sha256=VIc2ar6DhP0mQ9RVYrGRlTNPuKO3DUu9kwjJVC_E3cY,894
+orgo-0.0.39.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+orgo-0.0.39.dist-info/top_level.txt,sha256=q0rYtFji8GbYuhFW8A5Ab9e0j27761IKPhnL0E9xow4,5
+orgo-0.0.39.dist-info/RECORD,,