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

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.38.dist-info → orgo-0.0.39.dist-info}/METADATA

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

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

@@ -2,12 +2,12 @@ orgo/__init__.py,sha256=7uMYbhVNVUtrH7mCd8Ofll36EIdR92LcVlF7bdKuVR4,206
 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.38.dist-info/METADATA,sha256=MZobQck4x8Oe-BNauzyRjY_GOjLXxrc6ee1dWXGIcpQ,894
-orgo-0.0.38.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-orgo-0.0.38.dist-info/top_level.txt,sha256=q0rYtFji8GbYuhFW8A5Ab9e0j27761IKPhnL0E9xow4,5
-orgo-0.0.38.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,,