orgo 0.0.34__tar.gz → 0.0.37__tar.gz

{orgo-0.0.34 → orgo-0.0.37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orgo
-Version: 0.0.34
+Version: 0.0.37
 Summary: Computers for AI agents
 Author: Orgo Team
 License: MIT
@@ -8,8 +8,10 @@ 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
+Requires-Dist: requests>=2.28.0
+Requires-Dist: pillow>=9.0.0
+Requires-Dist: anthropic>=0.50.0
+Requires-Dist: websocket-client>=1.6.0
 
 # Orgo SDK
 

{orgo-0.0.34 → orgo-0.0.37}/pyproject.toml

@@ -4,15 +4,17 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "orgo"
-version = "0.0.34"
+version = "0.0.37"
 description = "Computers for AI agents"
 authors = [{name = "Orgo Team"}]
 license = {text = "MIT"}
 readme = "README.md"
 requires-python = ">=3.7"
 dependencies = [
-    "requests>=2.25.0",
-    "pillow>=8.0.0",
+    "requests>=2.28.0",
+    "pillow>=9.0.0",
+    "anthropic>=0.50.0",
+    "websocket-client>=1.6.0",
 ]
 
 [project.urls]

{orgo-0.0.34 → orgo-0.0.37}/src/orgo/computer.py

@@ -1,4 +1,13 @@
-"""Computer class for interacting with Orgo virtual environments"""
+"""
+Orgo Computer - Control virtual computers with AI.
+
+Usage:
+    from orgo import Computer
+    
+    computer = Computer(computer_id="your-computer-id")
+    computer.prompt("Open Firefox and search for AI news")
+"""
+
 import os as operating_system
 import base64
 import logging
@@ -14,7 +23,25 @@ from .prompt import get_provider
 
 logger = logging.getLogger(__name__)
 
+
 class Computer:
+    """
+    Control an Orgo virtual computer.
+    
+    Examples:
+        # Connect to existing computer
+        computer = Computer(computer_id="abc123")
+        
+        # Create new computer in project
+        computer = Computer(project="my-project", ram=4, cpu=2)
+        
+        # AI control (uses Orgo by default)
+        computer.prompt("Open Firefox")
+        
+        # AI control with Anthropic directly
+        computer.prompt("Open Firefox", provider="anthropic")
+    """
+    
     def __init__(self, 
                  project: Optional[Union[str, 'Project']] = None,
                  name: Optional[str] = None,
@@ -31,187 +58,136 @@ class Computer:
         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)
+            computer_id: Connect to existing computer by ID
+            project: Project name or Project instance
+            name: Computer name (auto-generated if not provided)
             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
-            image: Custom image reference (str) or Forge object - only used when creating
-        
-        Examples:
-            # Create computer in new project
-            computer = Computer(ram=4, cpu=2)
-            
-            # Create computer with custom image
-            forge = Forge(org_id="myorg", project_id="myproj").base("ubuntu").run("echo hello")
-            computer = Computer(image=forge)
-            
-            # 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")
+            base_api_url: Custom API URL
+            ram/memory: RAM in GB (1, 2, 4, 8, 16, 32, 64)
+            cpu: CPU cores (1, 2, 4, 8, 16)
+            os: "linux" or "windows"
+            gpu: "none", "a10", "l40s", "a100-40gb", "a100-80gb"
+            image: Custom image reference or Forge object
         """
         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"
-        
-        # Handle image
         self.image = image
+        
         if hasattr(self.image, 'build') and callable(self.image.build):
             logger.info("Building image from Forge object...")
             self.image = self.image.build()
         
         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}")
+            logger.info(f"Connected to computer: {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")
+                    raise ValueError("project must be a string or Project instance")
         else:
-            # No project specified, create a new one
             self._create_new_project_and_computer(name)
     
+    # =========================================================================
+    # Initialization Helpers
+    # =========================================================================
+    
     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")
+            logger.info(f"Creating new project: {project_name}")
             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})")
+        logger.info(f"Connected to: {self.name} ({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
+        # Validate
         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")
+            raise ValueError("ram must be: 1, 2, 4, 8, 16, 32, or 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")
+            raise ValueError("cpu must be: 1, 2, 4, 8, or 16 cores")
         if self.os not in ["linux", "windows"]:
-            raise ValueError("os must be either 'linux' or 'windows'")
+            raise ValueError("os must be: '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'")
-            
-        # Resolve image name if needed
+            raise ValueError("gpu must be: 'none', 'a10', 'l40s', 'a100-40gb', or 'a100-80gb'")
+        
+        # Resolve image
         image_ref = self.image
         if image_ref and isinstance(image_ref, str) and not image_ref.startswith("registry.fly.io"):
-            logger.info(f"Resolving image name '{image_ref}'...")
             try:
-                # Try to get org_id from project info
                 project_info = self.api.get_project(project_id)
-                org_id = project_info.get("org_id", "orgo") # Default to 'orgo'
-                
+                org_id = project_info.get("org_id", "orgo")
                 response = self.api.get_latest_build(org_id, project_id, image_ref)
                 if response and response.get("build"):
-                    resolved_ref = response.get("build", {}).get("imageRef")
-                    if resolved_ref:
-                        logger.info(f"Resolved '{image_ref}' to '{resolved_ref}'")
-                        image_ref = resolved_ref
-                    else:
-                        logger.warning(f"Build found for '{image_ref}' but no imageRef present.")
-                else:
-                    logger.warning(f"Could not resolve image name '{self.image}'. Using as is.")
+                    resolved = response.get("build", {}).get("imageRef")
+                    if resolved:
+                        image_ref = resolved
             except Exception as e:
-                logger.warning(f"Failed to resolve image name: {e}")
+                logger.warning(f"Failed to resolve image: {e}")
         
         computer = self.api.create_computer(
             project_id=project_id,
@@ -223,54 +199,67 @@ class Computer:
             image=image_ref
         )
         self.computer_id = computer.get("id")
-        logger.info(f"Created new computer {self.name} (ID: {self.computer_id})")
+        logger.info(f"Created: {self.name} ({self.computer_id})")
+    
+    # =========================================================================
+    # Computer Management
+    # =========================================================================
     
     def status(self) -> Dict[str, Any]:
-        """Get current computer status"""
+        """Get current computer status."""
         return self.api.get_computer(self.computer_id)
     
     def restart(self) -> Dict[str, Any]:
-        """Restart the computer"""
+        """Restart the computer."""
         return self.api.restart_computer(self.computer_id)
     
     def destroy(self) -> Dict[str, Any]:
-        """Terminate and delete the computer instance"""
+        """Delete the computer."""
         return self.api.delete_computer(self.computer_id)
     
-    # Navigation methods
+    # =========================================================================
+    # Mouse Actions
+    # =========================================================================
+    
     def left_click(self, x: int, y: int) -> Dict[str, Any]:
-        """Perform left mouse click at specified coordinates"""
+        """Left click at 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"""
+        """Right click at 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"""
+        """Double click at 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"""
+        """Drag 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"""
+        """Scroll in direction."""
         return self.api.scroll(self.computer_id, direction, amount)
     
-    # Input methods
+    # =========================================================================
+    # Keyboard Actions
+    # =========================================================================
+    
     def type(self, text: str) -> Dict[str, Any]:
-        """Type the specified text"""
+        """Type 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")"""
+        """Press key (e.g., "Enter", "ctrl+c")."""
         return self.api.key_press(self.computer_id, key)
     
-    # View methods
+    # =========================================================================
+    # Screen Capture
+    # =========================================================================
+    
     def screenshot(self) -> Image.Image:
-        """Capture screenshot and return as PIL Image"""
+        """Capture screenshot as PIL Image."""
         response = self.api.get_screenshot(self.computer_id)
         image_data = response.get("image", "")
         
@@ -279,11 +268,10 @@ class Computer:
             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))
+            return Image.open(io.BytesIO(base64.b64decode(image_data)))
     
     def screenshot_base64(self) -> str:
-        """Capture screenshot and return as base64 string"""
+        """Capture screenshot as base64 string."""
         response = self.api.get_screenshot(self.computer_id)
         image_data = response.get("image", "")
         
@@ -291,58 +279,102 @@ class Computer:
             img_response = requests.get(image_data)
             img_response.raise_for_status()
             return base64.b64encode(img_response.content).decode('utf-8')
-        else:
-            return image_data
+        return image_data
+    
+    # =========================================================================
+    # Code Execution
+    # =========================================================================
     
-    # Execution methods
     def bash(self, command: str) -> str:
-        """Execute a bash command and return output"""
+        """Execute bash command."""
         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
+        """Execute Python code."""
+        return self.api.execute_python(self.computer_id, code, timeout)
     
     def wait(self, seconds: float) -> Dict[str, Any]:
-        """Wait for specified number of seconds"""
+        """Wait for seconds."""
         return self.api.wait(self.computer_id, seconds)
     
-    # Streaming methods
+    # =========================================================================
+    # Streaming
+    # =========================================================================
+    
     def start_stream(self, connection: str) -> Dict[str, Any]:
-        """Start streaming the computer screen to an RTMP server"""
+        """Start RTMP stream."""
         return self.api.start_stream(self.computer_id, connection)
     
     def stop_stream(self) -> Dict[str, Any]:
-        """Stop the active stream"""
+        """Stop stream."""
         return self.api.stop_stream(self.computer_id)
     
     def stream_status(self) -> Dict[str, Any]:
-        """Get the current streaming status"""
+        """Get stream status."""
         return self.api.get_stream_status(self.computer_id)
     
-    # AI control method
+    # =========================================================================
+    # AI Control
+    # =========================================================================
+    
     def prompt(self, 
                instruction: str,
-               provider: str = "anthropic",
+               provider: Optional[str] = None,
+               verbose: bool = True,
+               callback: Optional[Callable[[str, Any], None]] = None,
                model: str = "claude-sonnet-4-5-20250929",
                display_width: int = 1024,
                display_height: int = 768,
-               callback: Optional[Callable[[str, Any], None]] = None,
-               thinking_enabled: bool = False,
+               thinking_enabled: bool = True,
                thinking_budget: int = 1024,
                max_tokens: int = 4096,
-               max_iterations: int = 20,
-               max_saved_screenshots: int = 5,
+               max_iterations: int = 100,
+               max_saved_screenshots: int = 3,
+               system_prompt: Optional[str] = None,
                api_key: Optional[str] = None) -> List[Dict[str, Any]]:
-        """Control the computer with natural language instructions using an AI assistant"""
+        """
+        Control the computer with natural language.
+        
+        Args:
+            instruction: What you want the computer to do
+            provider: "orgo" (default) or "anthropic"
+            verbose: Show progress logs (default: True)
+            callback: Optional callback for events
+            model: AI model to use
+            display_width: Screen width
+            display_height: Screen height
+            thinking_enabled: Enable extended thinking
+            thinking_budget: Token budget for thinking
+            max_tokens: Max response tokens
+            max_iterations: Max agent iterations
+            max_saved_screenshots: Screenshots to keep in context
+            system_prompt: Custom instructions
+            api_key: Anthropic key (only for provider="anthropic")
+        
+        Returns:
+            List of conversation messages
+        
+        Examples:
+            # Default: Uses Orgo hosted agent
+            computer.prompt("Open Firefox and search for AI news")
+            
+            # Quiet mode (no logs)
+            computer.prompt("Open Firefox", verbose=False)
+            
+            # Use Anthropic directly
+            computer.prompt("Open Firefox", provider="anthropic")
+            
+            # With callback
+            computer.prompt("Search Google", callback=lambda t, d: print(f"{t}: {d}"))
+        """
         provider_instance = get_provider(provider)
         
         return provider_instance.execute(
             computer_id=self.computer_id,
             instruction=instruction,
             callback=callback,
+            verbose=verbose,
             api_key=api_key,
             model=model,
             display_width=display_width,
@@ -352,11 +384,21 @@ class Computer:
             max_tokens=max_tokens,
             max_iterations=max_iterations,
             max_saved_screenshots=max_saved_screenshots,
+            system_prompt=system_prompt,
             orgo_api_key=self.api_key,
             orgo_base_url=self.base_api_url
         )
     
+    # =========================================================================
+    # URL Helper
+    # =========================================================================
+    
+    @property
+    def url(self) -> str:
+        """Get the URL to view this computer."""
+        return f"https://orgo.ai/workspaces/{self.computer_id}"
+    
     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})"
+        if hasattr(self, 'name') and self.name:
+            return f"Computer(name='{self.name}', id='{self.computer_id}')"
+        return f"Computer(id='{self.computer_id}')"