agnt5 0.1.1__cp39-abi3-manylinux_2_34_x86_64.whl

agnt5/__init__.py

@@ -0,0 +1,27 @@
+"""
+AGNT5 Python SDK - Build durable, resilient agent-first applications.
+
+This SDK provides high-level components for building agents, tools, and workflows
+with built-in durability guarantees and state management, backed by a high-performance
+Rust core.
+"""
+
+from .version import _get_version
+# Import compatibility checks
+from ._compat import _rust_available, _import_error
+
+# Import decorators
+from .decorators import function
+
+# Import high-level Worker
+from .worker_manager import Worker
+
+__version__ = _get_version()
+
+
+# Import the Rust core if available
+if _rust_available:
+    from ._core import (
+        PyWorker
+    )
+

agnt5/_compat.py

@@ -0,0 +1,15 @@
+"""
+Compatibility utilities for the AGNT5 Python SDK.
+
+This module handles runtime compatibility checks and provides utilities
+for cross-referencing throughout the project.
+"""
+
+# Check if Rust core is available
+try:
+    from . import _core
+    _rust_available = True
+    _import_error = None
+except ImportError as e:
+    _rust_available = False
+    _import_error = e

agnt5/decorators.py

@@ -0,0 +1,198 @@
+"""
+Function decorators for AGNT5 workers.
+
+This module provides decorators for registering functions as handlers
+that can be invoked through the AGNT5 platform.
+"""
+
+import functools
+import inspect
+import logging
+from typing import Any, Callable, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+# Global registry of decorated functions
+_function_registry: Dict[str, Callable] = {}
+
+
+def function(name: str = None):
+    """
+    Decorator to register a function as an AGNT5 handler.
+    
+    Args:
+        name: The name to register the function under. If None, uses the function's name.
+        
+    Usage:
+        @function("add_numbers")
+        def add_numbers(ctx, a: int, b: int) -> int:
+            return a + b
+            
+        @function()
+        def greet_user(ctx, name: str) -> str:
+            return f"Hello, {name}!"
+    """
+    def decorator(func: Callable) -> Callable:
+        handler_name = name if name is not None else func.__name__
+        
+        # Store function metadata
+        func._agnt5_handler_name = handler_name
+        func._agnt5_is_function = True
+        
+        # Register in global registry
+        _function_registry[handler_name] = func
+        
+        logger.debug(f"Registered function handler: {handler_name}")
+        
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            return func(*args, **kwargs)
+        
+        # Copy metadata to wrapper
+        wrapper._agnt5_handler_name = handler_name
+        wrapper._agnt5_is_function = True
+        
+        return wrapper
+    
+    return decorator
+
+
+def get_registered_functions() -> Dict[str, Callable]:
+    """
+    Get all registered function handlers.
+    
+    Returns:
+        Dictionary mapping handler names to functions
+    """
+    return _function_registry.copy()
+
+
+def get_function_metadata(func: Callable) -> Optional[Dict[str, Any]]:
+    """
+    Extract metadata from a decorated function.
+    
+    Args:
+        func: The function to extract metadata from
+        
+    Returns:
+        Dictionary with function metadata or None if not decorated
+    """
+    if not hasattr(func, '_agnt5_is_function'):
+        return None
+        
+    signature = inspect.signature(func)
+    parameters = []
+    
+    for param_name, param in signature.parameters.items():
+        if param_name == 'ctx':  # Skip context parameter
+            continue
+            
+        param_info = {
+            'name': param_name,
+            'type': 'any'  # Default type, could be enhanced with type hints
+        }
+        
+        # Extract type information if available
+        if param.annotation != inspect.Parameter.empty:
+            param_info['type'] = str(param.annotation.__name__ if hasattr(param.annotation, '__name__') else param.annotation)
+            
+        if param.default != inspect.Parameter.empty:
+            param_info['default'] = param.default
+            
+        parameters.append(param_info)
+    
+    return {
+        'name': func._agnt5_handler_name,
+        'type': 'function',
+        'parameters': parameters,
+        'return_type': str(signature.return_annotation.__name__ if signature.return_annotation != inspect.Parameter.empty else 'any')
+    }
+
+
+def clear_registry():
+    """Clear the function registry. Mainly for testing."""
+    global _function_registry
+    _function_registry.clear()
+
+
+def invoke_function(handler_name: str, input_data: bytes, context: Any = None) -> bytes:
+    """
+    Invoke a registered function handler.
+    
+    Args:
+        handler_name: Name of the handler to invoke
+        input_data: Input data as bytes (will be decoded from JSON)
+        context: Execution context
+        
+    Returns:
+        Function result as bytes (JSON encoded)
+        
+    Raises:
+        ValueError: If handler is not found
+        RuntimeError: If function execution fails
+    """
+    import json
+    
+    if handler_name not in _function_registry:
+        raise ValueError(f"Handler '{handler_name}' not found")
+    
+    func = _function_registry[handler_name]
+    
+    try:
+        # Decode input data
+        if input_data:
+            print(f"📨 Received function invocation: {handler_name}")
+            
+            # Check if this is protobuf data by looking for the pattern
+            try:
+                raw_data = input_data.decode('utf-8')
+                input_params = json.loads(raw_data)
+            except (UnicodeDecodeError, json.JSONDecodeError):
+                # This is protobuf data - extract the JSON payload
+                # The JSON is embedded after the \x1a<length> pattern
+                start_idx = input_data.find(b'\x1a')
+                if start_idx != -1 and start_idx + 1 < len(input_data):
+                    # The byte after \x1a indicates the length of the JSON data
+                    json_length = input_data[start_idx + 1]
+                    json_start = start_idx + 2
+                    
+                    if json_start + json_length <= len(input_data):
+                        json_bytes = input_data[json_start:json_start + json_length]
+                        raw_data = json_bytes.decode('utf-8')
+                        print(f"📋 Extracted JSON from protobuf: {raw_data}")
+                        input_params = json.loads(raw_data)
+                    else:
+                        raise ValueError("Invalid protobuf structure - JSON length exceeds available data")
+                else:
+                    raise ValueError("Could not find JSON data in protobuf message")
+        else:
+            input_params = {}
+            
+        logger.debug(f"Invoking function {handler_name} with params: {input_params}")
+        
+        # Call function with context as first parameter
+        if isinstance(input_params, dict):
+            result = func(context, **input_params)
+        else:
+            # Handle case where input is not a dict (e.g., single value)
+            result = func(context, input_params)
+            
+        # Encode result
+        if result is None:
+            result_data = b""
+        else:
+            result_json = json.dumps(result)
+            result_data = result_json.encode('utf-8')
+            
+        logger.debug(f"Function {handler_name} completed successfully")
+        return result_data
+        
+    except json.JSONDecodeError as e:
+        print(f"❌ JSON parsing failed: {e}")
+        print(f"📋 Failed to parse: {repr(raw_data if 'raw_data' in locals() else 'No raw_data available')}")
+        logger.error(f"JSON decode error for {handler_name}: {e}")
+        raise RuntimeError(f"Invalid JSON input: {e}")
+    except Exception as e:
+        print(f"❌ Function '{handler_name}' failed: {type(e).__name__}: {e}")
+        logger.error(f"Function {handler_name} failed: {e}")
+        raise RuntimeError(f"Function execution failed: {e}")

agnt5/version.py

@@ -0,0 +1,23 @@
+
+
+# Read version from pyproject.toml to maintain single source of truth
+def _get_version():
+    try:
+        import tomllib
+    except ImportError:
+        # Python < 3.11 fallback
+        try:
+            import tomli as tomllib
+        except ImportError:
+            # Final fallback if no toml library available
+            return "UNKNOWN"
+    
+    try:
+        import pathlib
+        pyproject_path = pathlib.Path(__file__).parent.parent.parent / "pyproject.toml"
+        with open(pyproject_path, "rb") as f:
+            pyproject_data = tomllib.load(f)
+        return pyproject_data["project"]["version"]
+    except Exception:
+        # Fallback version if reading fails
+        return "UNKNOWN"

agnt5/worker.py

@@ -0,0 +1,44 @@
+from ._compat import _rust_available, _import_error
+
+def get_worker(
+    service_name: str,
+    service_version: str = "1.0.0",
+    coordinator_endpoint: str = None,
+    auto_register: bool = True,
+) -> "DurableWorker":
+    """
+    Create a new durable worker using the Rust core.
+
+    Args:
+        service_name: Name of the service
+        service_version: Version of the service
+        coordinator_endpoint: Endpoint of the coordinator service
+        auto_register: Whether to automatically register decorated components
+
+    Returns:
+        A configured DurableWorker instance
+
+    Raises:
+        RuntimeError: If the Rust core is not available
+    """
+    if not _rust_available:
+        raise RuntimeError(f"Rust core is required but not available: {_import_error}. Please build and install the Rust extension first.")
+
+    # Use the high-performance Rust core
+    import uuid
+
+    worker_id = str(uuid.uuid4())
+
+    rust_worker = create_worker(
+        worker_id=worker_id,
+        service_name=service_name,
+        version=service_version,
+        coordinator_endpoint=coordinator_endpoint,
+    )
+
+    worker = DurableWorker(rust_worker)
+    
+    # Store auto-registration preference for later use
+    worker._auto_register = auto_register
+    
+    return worker

agnt5/worker_manager.py

@@ -0,0 +1,163 @@
+"""
+High-level Worker manager that integrates function decorators with the Rust core.
+"""
+
+import logging
+import time
+from typing import Any, Dict, List, Optional
+
+from ._compat import _rust_available, _import_error
+from .decorators import get_registered_functions, get_function_metadata, invoke_function
+
+logger = logging.getLogger(__name__)
+
+
+class Worker:
+    """
+    High-level AGNT5 Worker that automatically registers decorated functions.
+    
+    This class wraps the low-level Rust PyWorker and provides automatic
+    registration of @function decorated handlers.
+    """
+    
+    def __init__(self, 
+                 service_name: str,
+                 service_version: str = "1.0.0",
+                 coordinator_endpoint: str = "http://localhost:9091"):
+        """
+        Initialize the worker.
+        
+        Args:
+            service_name: Name of the service
+            service_version: Version of the service  
+            coordinator_endpoint: Endpoint of the coordinator service
+        """
+        if not _rust_available:
+            raise RuntimeError(f"Rust core is required but not available: {_import_error}")
+            
+        self.service_name = service_name
+        self.service_version = service_version
+        self.coordinator_endpoint = coordinator_endpoint
+        
+        # Import and create Rust worker
+        from ._core import PyWorker
+        self._rust_worker = PyWorker(
+            coordinator_endpoint, 
+            service_name, 
+            service_version, 
+            "python"
+        )
+        
+        self._running = False
+        
+        logger.info(f"Worker created: {service_name} v{service_version}")
+        
+    @property
+    def worker_id(self) -> str:
+        """Get the worker ID."""
+        return self._rust_worker.worker_id()
+    
+    @property 
+    def tenant_id(self) -> Optional[str]:
+        """Get the tenant ID."""
+        return self._rust_worker.tenant_id()
+    
+    @property
+    def deployment_id(self) -> Optional[str]:
+        """Get the deployment ID."""
+        return self._rust_worker.deployment_id()
+    
+    def start(self):
+        """
+        Start the worker and register all decorated functions.
+        
+        This will:
+        1. Start the underlying Rust worker
+        2. Wait for successful registration with coordinator
+        3. Collect all @function decorated handlers
+        """
+        logger.info(f"Starting worker {self.service_name}...")
+        
+        # Start the Rust worker first
+        self._rust_worker.start()
+        
+        # Give it a moment to connect and register
+        # TODO: Replace with proper callback mechanism from Rust core
+        time.sleep(1.0)  # Increased timeout for registration
+        
+        # Check if worker is still running (registration successful)
+        if not self._rust_worker.is_running():
+            raise RuntimeError(f"Worker {self.service_name} failed to start or register")
+        
+        # Register all decorated functions
+        self._register_functions()
+        
+        self._running = True
+        logger.info(f"Worker {self.service_name} connected and registered successfully")
+        
+    def stop(self):
+        """Stop the worker."""
+        logger.info(f"Stopping worker {self.service_name}...")
+        
+        self._running = False
+        self._rust_worker.stop()
+        
+        logger.info(f"Worker {self.service_name} stopped")
+        
+    def is_running(self) -> bool:
+        """Check if the worker is running."""
+        return self._running and self._rust_worker.is_running()
+        
+    def _register_functions(self):
+        """Register all decorated functions with the Worker Coordinator."""
+        functions = get_registered_functions()
+        
+        if not functions:
+            logger.warning("No @function decorated handlers found")
+            return
+            
+        logger.info(f"Registering {len(functions)} function handlers: {list(functions.keys())}")
+        
+        # Build component list for registration
+        components = []
+        for handler_name, func in functions.items():
+            metadata = get_function_metadata(func)
+            if metadata:
+                components.append({
+                    'name': handler_name,
+                    'type': 'function',
+                    'metadata': metadata
+                })
+                
+        # TODO: Use the Rust worker to send registration message
+        # For now, just log the components that would be registered
+        logger.info(f"Would register components: {components}")
+        
+    def handle_invocation(self, handler_name: str, input_data: bytes) -> bytes:
+        """
+        Handle a function invocation request.
+        
+        Args:
+            handler_name: Name of the handler to invoke
+            input_data: Input data as bytes
+            
+        Returns:
+            Function result as bytes
+        """
+        logger.info(f"Handling invocation: {handler_name}")
+        
+        try:
+            # Create a basic context object
+            context = {
+                'worker_id': self.worker_id,
+                'service_name': self.service_name,
+                'handler_name': handler_name
+            }
+            
+            result = invoke_function(handler_name, input_data, context)
+            logger.info(f"Invocation {handler_name} completed successfully")
+            return result
+            
+        except Exception as e:
+            logger.error(f"Invocation {handler_name} failed: {e}")
+            raise

agnt5-0.1.1.dist-info/METADATA

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: agnt5
+Version: 0.1.1
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: maturin>=1.9.3
+Summary: AGNT5 Python SDK - Build durable, resilient agent-first applications
+Author-email: AGNT5 Team <team@agnt5.com>
+License: Apache-2.0
+Requires-Python: >=3.9
+Project-URL: Homepage, https://agnt5.dev
+Project-URL: Documentation, https://docs.agnt5.dev

agnt5-0.1.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+agnt5-0.1.1.dist-info/METADATA,sha256=aAtTmCD-mFWTHk6haLGMlGgJ1-UAW6Wu6zPg39RkLpY,723
+agnt5-0.1.1.dist-info/WHEEL,sha256=guJ13TuUSdW6egu2dQFaUYWK4XNy1vwwrD1h7QU7oIo,106
+agnt5/__init__.py,sha256=RQMVsOLj01XYYPjOWkQgohOZcmDLc3iMWZ8il7t5f38,630
+agnt5/_compat.py,sha256=jNfxdubYi3XbhPN6_bAXP4TCEdocZltiB4r2AugiWl4,367
+agnt5/_core.abi3.so,sha256=CwPuj55fKL90PUHBOOwuBugwe3Dji3d7_QWgCkBZV-Q,3345896
+agnt5/decorators.py,sha256=iSnKN2vL48KQYC6tBG3sNzlCPDzCndJbyjhwn3VPUy8,6824
+agnt5/version.py,sha256=ZJQ4ut-NS1vc8qIEUnUqdfsBK0nCG60qdz34_b5H0co,703
+agnt5/worker.py,sha256=oyBzguGRpT7lOVQOlJxu4bT-7Dg1LaVzesb2c4m_gOk,1276
+agnt5/worker_manager.py,sha256=IiRy0zMUgf8VVs14XUDoYsNaiwYl-JaWB1EqgaXw4XA,5537
+agnt5-0.1.1.dist-info/RECORD,,

agnt5-0.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.9.3)
+Root-Is-Purelib: false
+Tag: cp39-abi3-manylinux_2_34_x86_64