orgo 0.0.1__py3-none-any.whl → 0.0.2__py3-none-any.whl

orgo/__init__.py

@@ -0,0 +1,5 @@
+"""Orgo SDK: Desktop infrastructure for AI agents"""
+
+from .computer import Computer
+
+__all__ = ["Computer"]

orgo/adapters/__init__.py

@@ -0,0 +1,7 @@
+"""Adapters for integrating Orgo with AI models"""
+
+from .base import BaseAdapter
+from .anthropic import AnthropicAdapter
+from .openai import OpenAIAdapter
+
+__all__ = ["BaseAdapter", "AnthropicAdapter", "OpenAIAdapter"]

orgo/adapters/anthropic.py

@@ -0,0 +1,64 @@
+"""Adapter for Anthropic's Claude"""
+
+from typing import Dict, Any, Optional
+from .base import BaseAdapter
+
+class AnthropicAdapter(BaseAdapter):
+    def get_tool_definition(self) -> Dict[str, Any]:
+        return {
+            "name": "computer",
+            "description": "Controls a virtual computer to automate tasks",
+            "type": "function",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "action": {
+                        "type": "string",
+                        "enum": ["left_click", "right_click", "double_click", "type", "key", "scroll", "screenshot"],
+                        "description": "The action to perform on the computer"
+                    },
+                    "coordinate": {
+                        "type": "array",
+                        "items": {"type": "number"},
+                        "description": "The x,y coordinates for click actions",
+                        "minItems": 2,
+                        "maxItems": 2
+                    },
+                    "text": {
+                        "type": "string",
+                        "description": "The text to type or key to press"
+                    },
+                    "direction": {
+                        "type": "string",
+                        "enum": ["up", "down", "left", "right"],
+                        "description": "The direction to scroll"
+                    },
+                    "amount": {
+                        "type": "number",
+                        "description": "The amount to scroll"
+                    }
+                },
+                "required": ["action"],
+                "additionalProperties": False
+            }
+        }
+    
+    def format_result(self, tool_id: str, output: Optional[str] = None, error: Optional[str] = None) -> Dict[str, Any]:
+        screenshot = self.computer.get_base64()
+        result = {
+            "type": "tool_result",
+            "id": tool_id,
+            "content": {
+                "type": "image",
+                "source": {
+                    "type": "base64",
+                    "media_type": "image/png",
+                    "data": screenshot
+                }
+            }
+        }
+        
+        if error:
+            result["error"] = error
+            
+        return result

orgo/adapters/base.py

@@ -0,0 +1,14 @@
+"""Base adapter for AI model integration"""
+
+from typing import Dict, Any, Optional
+from ..computer import Computer
+
+class BaseAdapter:
+    def __init__(self, computer: Computer):
+        self.computer = computer
+    
+    def get_tool_definition(self) -> Dict[str, Any]:
+        raise NotImplementedError("Subclasses must implement get_tool_definition()")
+    
+    def format_result(self, tool_id: str, output: Optional[str] = None, error: Optional[str] = None) -> Dict[str, Any]:
+        raise NotImplementedError("Subclasses must implement format_result()")

orgo/adapters/openai.py

@@ -0,0 +1,69 @@
+"""Adapter for OpenAI models"""
+
+from typing import Dict, Any, Optional
+from .base import BaseAdapter
+
+class OpenAIAdapter(BaseAdapter):
+    def get_tool_definition(self) -> Dict[str, Any]:
+        return {
+            "type": "function",
+            "function": {
+                "name": "computer",
+                "description": "Controls a virtual computer to automate tasks",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "action": {
+                            "type": "string",
+                            "enum": ["click", "right_click", "double_click", "type", "key", "scroll", "screenshot"],
+                            "description": "The action to perform on the computer"
+                        },
+                        "x": {
+                            "type": "number",
+                            "description": "The x coordinate for click actions"
+                        },
+                        "y": {
+                            "type": "number",
+                            "description": "The y coordinate for click actions"
+                        },
+                        "text": {
+                            "type": "string",
+                            "description": "The text to type or key to press"
+                        },
+                        "direction": {
+                            "type": "string",
+                            "enum": ["up", "down", "left", "right"],
+                            "description": "The direction to scroll"
+                        },
+                        "amount": {
+                            "type": "number",
+                            "description": "The amount to scroll"
+                        }
+                    },
+                    "required": ["action"],
+                    "additionalProperties": False
+                }
+            }
+        }
+    
+    def format_result(self, tool_id: str, output: Optional[str] = None, error: Optional[str] = None) -> Dict[str, Any]:
+        screenshot = self.computer.get_base64()
+        result = {
+            "tool_call_id": tool_id,
+            "content": [
+                {
+                    "type": "image_url",
+                    "image_url": {
+                        "url": f"data:image/png;base64,{screenshot}"
+                    }
+                }
+            ]
+        }
+        
+        if error:
+            result["content"].insert(0, {
+                "type": "text",
+                "text": f"Error: {error}"
+            })
+            
+        return result

orgo/api/__init__.py

@@ -0,0 +1,5 @@
+"""API package for Orgo SDK"""
+
+from .client import ApiClient
+
+__all__ = ["ApiClient"]

orgo/api/client.py

@@ -0,0 +1,101 @@
+"""Low-level API client for Orgo service"""
+
+import requests
+from typing import Dict, Any, Optional
+
+from orgo.utils.auth import get_api_key
+
+class ApiClient:
+    BASE_URL = "https://www.orgo.ai/api"
+    
+    def __init__(self, api_key: Optional[str] = None):
+        self.api_key = get_api_key(api_key)
+        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:
+            if hasattr(e, 'response') and e.response is not None:
+                error_message = f"API error: {e.response.status_code}"
+                try:
+                    error_data = e.response.json()
+                    if 'error' in error_data:
+                        error_message += f" - {error_data['error']}"
+                except ValueError:
+                    pass
+                raise Exception(error_message) from e
+            raise Exception(f"Connection error: {str(e)}") from e
+    
+    # Computer lifecycle methods
+    def create_computer(self) -> Dict[str, Any]:
+        return self._request("POST", "computers")
+    
+    def connect_computer(self, project_id: str) -> Dict[str, Any]:
+        return self._request("GET", f"computers/{project_id}")
+    
+    def get_status(self, project_id: str) -> Dict[str, Any]:
+        return self._request("GET", f"computers/{project_id}/status")
+    
+    def restart_computer(self, project_id: str) -> Dict[str, Any]:
+        return self._request("POST", f"computers/{project_id}/restart")
+    
+    def shutdown_computer(self, project_id: str) -> Dict[str, Any]:
+        return self._request("POST", f"computers/{project_id}/shutdown")
+    
+    # Computer control methods
+    def left_click(self, project_id: str, x: int, y: int) -> Dict[str, Any]:
+        return self._request("POST", f"computers/{project_id}/click", {
+            "button": "left", "x": x, "y": y
+        })
+    
+    def right_click(self, project_id: str, x: int, y: int) -> Dict[str, Any]:
+        return self._request("POST", f"computers/{project_id}/click", {
+            "button": "right", "x": x, "y": y
+        })
+    
+    def double_click(self, project_id: str, x: int, y: int) -> Dict[str, Any]:
+        return self._request("POST", f"computers/{project_id}/click", {
+            "button": "left", "x": x, "y": y, "double": True
+        })
+    
+    def scroll(self, project_id: str, direction: str, amount: int) -> Dict[str, Any]:
+        return self._request("POST", f"computers/{project_id}/scroll", {
+            "direction": direction, "amount": amount
+        })
+    
+    def type_text(self, project_id: str, text: str) -> Dict[str, Any]:
+        return self._request("POST", f"computers/{project_id}/type", {
+            "text": text
+        })
+    
+    def key_press(self, project_id: str, key: str) -> Dict[str, Any]:
+        return self._request("POST", f"computers/{project_id}/key", {
+            "key": key
+        })
+    
+    def get_screenshot(self, project_id: str) -> Dict[str, Any]:
+        return self._request("GET", f"computers/{project_id}/screenshot")
+    
+    def execute_bash(self, project_id: str, command: str) -> Dict[str, Any]:
+        return self._request("POST", f"computers/{project_id}/bash", {
+            "command": command
+        })
+    
+    def wait(self, project_id: str, seconds: float) -> Dict[str, Any]:
+        return self._request("POST", f"computers/{project_id}/wait", {
+            "seconds": seconds
+        })

orgo/computer.py

@@ -0,0 +1,84 @@
+"""Computer class for interacting with Orgo virtual environments"""
+
+import os
+import io
+import base64
+from typing import Dict, Any, Optional
+from PIL import Image
+
+from .api.client import ApiClient
+
+class Computer:
+    def __init__(self, project_id=None, api_key=None):
+        self.api = ApiClient(api_key or os.environ.get("ORGO_API_KEY"))
+        
+        if project_id:
+            self.project_id = project_id
+            self._info = self.api.connect_computer(project_id)
+        else:
+            response = self.api.create_computer()
+            self.project_id = response.get("project_id")
+            self._info = response
+            
+        if not self.project_id:
+            raise ValueError("Failed to initialize computer: No project ID returned")
+    
+    def status(self) -> Dict[str, Any]:
+        """Get current computer status"""
+        return self.api.get_status(self.project_id)
+    
+    def restart(self) -> Dict[str, Any]:
+        """Restart the computer"""
+        return self.api.restart_computer(self.project_id)
+    
+    def shutdown(self) -> Dict[str, Any]:
+        """Terminate the computer instance"""
+        return self.api.shutdown_computer(self.project_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.project_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.project_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.project_id, x, y)
+    
+    def scroll(self, direction: str = "down", amount: int = 1) -> Dict[str, Any]:
+        """Scroll in specified direction and amount"""
+        return self.api.scroll(self.project_id, direction, amount)
+    
+    # Input methods
+    def type(self, text: str) -> Dict[str, Any]:
+        """Type the specified text"""
+        return self.api.type_text(self.project_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.project_id, key)
+    
+    # View methods
+    def screenshot(self) -> Image.Image:
+        """Capture screenshot and return as PIL Image"""
+        response = self.api.get_screenshot(self.project_id)
+        img_data = base64.b64decode(response.get("screenshot", ""))
+        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.project_id)
+        return response.get("screenshot", "")
+    
+    # Execution methods
+    def bash(self, command: str) -> str:
+        """Execute a bash command and return output"""
+        response = self.api.execute_bash(self.project_id, command)
+        return response.get("output", "")
+    
+    def wait(self, seconds: float) -> Dict[str, Any]:
+        """Wait for specified number of seconds"""
+        return self.api.wait(self.project_id, seconds)

orgo/utils/__init__.py

@@ -0,0 +1,5 @@
+"""Utility functions for Orgo SDK"""
+
+from .auth import get_api_key
+
+__all__ = ["get_api_key"]

orgo/utils/auth.py

@@ -0,0 +1,16 @@
+"""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.2.dist-info/METADATA

@@ -0,0 +1,11 @@
+Metadata-Version: 2.2
+Name: orgo
+Version: 0.0.2
+Summary: Desktop infrastructure 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
+Requires-Dist: requests>=2.25.0
+Requires-Dist: pillow>=8.0.0

orgo-0.0.2.dist-info/RECORD

@@ -0,0 +1,14 @@
+orgo/__init__.py,sha256=SjO41JOwyLmX8K6fKu7LAIOyBk8sAtQKRaNVu2wZVBE,108
+orgo/computer.py,sha256=WJgCESNwDf4aU454upvwuAGwQgCD1zHti7faNOv73X0,3249
+orgo/adapters/__init__.py,sha256=LMpWJGVHvvSrLPhCJrMSENYSJ8ifWIpTfi88L6aN65I,219
+orgo/adapters/anthropic.py,sha256=KfPD5YWbwECZkpj421rSLCQf9SMr-EJ4nePe2EMXDWA,2342
+orgo/adapters/base.py,sha256=W1dNArKn1ri-X_36KuN-h5yxh1LmjIYCZMkKi9dm020,559
+orgo/adapters/openai.py,sha256=3NFmUYmaCSXHZImMvqj-fVc8oUxxrcU_6voBx2eFf5A,2605
+orgo/api/__init__.py,sha256=nE9fyIZw2q4mGqy063-1RAbBgy_Qhx11gN_swkhmbX8,86
+orgo/api/client.py,sha256=c-Wiymvre4v7psdgvu2aKZfBc7R8QimHfu5UrQl0H2s,4057
+orgo/utils/__init__.py,sha256=XSx9W-IPAc7yDnkwgED4v5eBUIQCxmokr_VQzF6LOZs,94
+orgo/utils/auth.py,sha256=mpnaOvM3BGIdZ_j9cTw8K34gPpCeLRrG0rZfoojzONc,484
+orgo-0.0.2.dist-info/METADATA,sha256=8NEJnaANllG7P4d4kg18tisNiaMjPC5q-zR3I3aavio,301
+orgo-0.0.2.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+orgo-0.0.2.dist-info/top_level.txt,sha256=q0rYtFji8GbYuhFW8A5Ab9e0j27761IKPhnL0E9xow4,5
+orgo-0.0.2.dist-info/RECORD,,

{orgo-0.0.1.dist-info → orgo-0.0.2.dist-info}/WHEEL

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

orgo-0.0.2.dist-info/top_level.txt

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

orgo-0.0.1.dist-info/METADATA

@@ -1,6 +0,0 @@
-Metadata-Version: 2.2
-Name: orgo
-Version: 0.0.1
-Author: Your Name
-License: MIT
-Requires-Python: >=3.6

orgo-0.0.1.dist-info/RECORD

@@ -1,4 +0,0 @@
-orgo-0.0.1.dist-info/METADATA,sha256=QmJjGIc_6GqPvO_7WUMBXJKMpeqgKXjJInHr7gSm0y4,102
-orgo-0.0.1.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-orgo-0.0.1.dist-info/top_level.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-orgo-0.0.1.dist-info/RECORD,,

orgo-0.0.1.dist-info/top_level.txt

@@ -1 +0,0 @@
-