replicantx 0.1.0__py3-none-any.whl

replicantx/__init__.py

@@ -0,0 +1,45 @@
+# Copyright 2025 Helix Technologies Limited
+# Licensed under the Apache License, Version 2.0 (see LICENSE file).
+"""
+ReplicantX - End-to-end testing harness for AI agents via web service APIs.
+
+This package provides tools for testing AI agents by calling their HTTP APIs
+with configurable authentication, assertions, and reporting.
+"""
+
+__version__ = "0.1.0"
+__author__ = "ReplicantX Team"
+__email__ = "team@replicantx.ai"
+
+from .models import (
+    Message,
+    Step,
+    StepResult,
+    ScenarioConfig,
+    ScenarioReport,
+    AuthConfig,
+    AssertionResult,
+    TestSuiteReport,
+    AuthProvider,
+    TestLevel,
+    AssertionType,
+    ReplicantConfig,
+    LLMConfig,
+)
+
+__all__ = [
+    "__version__",
+    "Message",
+    "Step", 
+    "StepResult",
+    "ScenarioConfig",
+    "ScenarioReport", 
+    "AuthConfig",
+    "AssertionResult",
+    "TestSuiteReport",
+    "AuthProvider",
+    "TestLevel",
+    "AssertionType",
+    "ReplicantConfig",
+    "LLMConfig",
+] 

replicantx/auth/__init__.py

@@ -0,0 +1,20 @@
+# Copyright 2025 Helix Technologies Limited
+# Licensed under the Apache License, Version 2.0 (see LICENSE file).
+"""
+Authentication module for ReplicantX.
+
+This module provides authentication providers for different services including
+Supabase, JWT, and no-auth options.
+"""
+
+from .base import AuthBase
+from .supabase import SupabaseAuth
+from .jwt import JWTAuth
+from .noop import NoopAuth
+
+__all__ = [
+    "AuthBase",
+    "SupabaseAuth", 
+    "JWTAuth",
+    "NoopAuth",
+] 

replicantx/auth/base.py

@@ -0,0 +1,74 @@
+# Copyright 2025 Helix Technologies Limited
+# Licensed under the Apache License, Version 2.0 (see LICENSE file).
+"""
+Base authentication class for ReplicantX.
+
+This module defines the abstract base class that all authentication providers
+must inherit from to provide a consistent interface.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Dict, Optional
+
+from ..models import AuthConfig
+
+
+class AuthBase(ABC):
+    """Abstract base class for authentication providers."""
+    
+    def __init__(self, config: AuthConfig):
+        """Initialize the authentication provider.
+        
+        Args:
+            config: Authentication configuration
+        """
+        self.config = config
+        self._token: Optional[str] = None
+        self._headers: Dict[str, str] = {}
+    
+    @abstractmethod
+    async def authenticate(self) -> str:
+        """Authenticate and return a token.
+        
+        Returns:
+            Authentication token
+            
+        Raises:
+            AuthenticationError: If authentication fails
+        """
+        pass
+    
+    @abstractmethod
+    async def get_headers(self) -> Dict[str, str]:
+        """Get authentication headers for HTTP requests.
+        
+        Returns:
+            Dictionary of headers to include in requests
+        """
+        pass
+    
+    async def token(self) -> str:
+        """Get the current authentication token.
+        
+        This method caches the token and only re-authenticates if necessary.
+        
+        Returns:
+            Current authentication token
+        """
+        if self._token is None:
+            self._token = await self.authenticate()
+        return self._token
+    
+    def invalidate_token(self) -> None:
+        """Invalidate the current token, forcing re-authentication on next request."""
+        self._token = None
+        self._headers.clear()
+
+
+class AuthenticationError(Exception):
+    """Raised when authentication fails."""
+    
+    def __init__(self, message: str, provider: str):
+        self.message = message
+        self.provider = provider
+        super().__init__(f"Authentication failed for {provider}: {message}") 

replicantx/auth/jwt.py

@@ -0,0 +1,102 @@
+# Copyright 2025 Helix Technologies Limited
+# Licensed under the Apache License, Version 2.0 (see LICENSE file).
+"""
+JWT authentication provider for ReplicantX.
+
+This module provides authentication using pre-minted JWT tokens,
+typically provided via environment variables or configuration.
+"""
+
+import os
+from typing import Dict
+
+from .base import AuthBase, AuthenticationError
+from ..models import AuthConfig
+
+
+class JWTAuth(AuthBase):
+    """JWT authentication provider using pre-minted tokens."""
+    
+    def __init__(self, config: AuthConfig):
+        """Initialize JWT authentication.
+        
+        Args:
+            config: Authentication configuration with JWT token
+        """
+        super().__init__(config)
+    
+    def _substitute_env_vars(self, value: str) -> str:
+        """Substitute environment variables in string values.
+        
+        Args:
+            value: String that may contain {{ env.VAR_NAME }} patterns
+            
+        Returns:
+            String with environment variables substituted
+        """
+        if not value:
+            return value
+        
+        # Simple template substitution for {{ env.VAR_NAME }}
+        import re
+        def replace_env_var(match):
+            var_name = match.group(1)
+            env_value = os.getenv(var_name)
+            if env_value is None:
+                raise ValueError(f"Environment variable {var_name} not found")
+            return env_value
+        
+        return re.sub(r'\{\{\s*env\.([A-Z_]+)\s*\}\}', replace_env_var, value)
+    
+    async def authenticate(self) -> str:
+        """Return the JWT token.
+        
+        Returns:
+            JWT token for API requests
+            
+        Raises:
+            AuthenticationError: If token is missing or invalid
+        """
+        try:
+            if not self.config.token:
+                raise AuthenticationError(
+                    "JWT token not provided in configuration",
+                    "jwt"
+                )
+            
+            # Substitute environment variables in token
+            token = self._substitute_env_vars(self.config.token)
+            
+            if not token:
+                raise AuthenticationError(
+                    "JWT token is empty after environment variable substitution",
+                    "jwt"
+                )
+            
+            return token
+            
+        except Exception as e:
+            if isinstance(e, AuthenticationError):
+                raise
+            raise AuthenticationError(
+                f"JWT authentication failed: {str(e)}", 
+                "jwt"
+            )
+    
+    async def get_headers(self) -> Dict[str, str]:
+        """Get authentication headers for HTTP requests.
+        
+        Returns:
+            Dictionary with Authorization header
+        """
+        token = await self.token()
+        headers = {
+            "Authorization": f"Bearer {token}",
+            "Content-Type": "application/json",
+        }
+        
+        # Add any additional headers from config
+        if self.config.headers:
+            headers.update(self.config.headers)
+        
+        return headers 

replicantx/auth/noop.py

@@ -0,0 +1,49 @@
+# Copyright 2025 Helix Technologies Limited
+# Licensed under the Apache License, Version 2.0 (see LICENSE file).
+"""
+No-op authentication provider for ReplicantX.
+
+This module provides a no-authentication provider for testing purposes
+or when working with APIs that don't require authentication.
+"""
+
+from typing import Dict
+
+from .base import AuthBase
+from ..models import AuthConfig
+
+
+class NoopAuth(AuthBase):
+    """No-op authentication provider that provides no authentication."""
+    
+    def __init__(self, config: AuthConfig):
+        """Initialize noop authentication.
+        
+        Args:
+            config: Authentication configuration (not used for noop)
+        """
+        super().__init__(config)
+    
+    async def authenticate(self) -> str:
+        """Return empty token for no authentication.
+        
+        Returns:
+            Empty string (no token needed)
+        """
+        return ""
+    
+    async def get_headers(self) -> Dict[str, str]:
+        """Get authentication headers for HTTP requests.
+        
+        Returns:
+            Dictionary with basic headers (no authentication)
+        """
+        headers = {
+            "Content-Type": "application/json",
+        }
+        
+        # Add any additional headers from config
+        if self.config.headers:
+            headers.update(self.config.headers)
+        
+        return headers 

replicantx/auth/supabase.py

@@ -0,0 +1,147 @@
+# Copyright 2025 Helix Technologies Limited
+# Licensed under the Apache License, Version 2.0 (see LICENSE file).
+"""
+Supabase authentication provider for ReplicantX.
+
+This module provides authentication via Supabase's email/password flow,
+managing session tokens and providing them as Bearer tokens for API requests.
+"""
+
+import os
+from typing import Dict
+
+from supabase import create_client, Client
+
+from .base import AuthBase, AuthenticationError
+from ..models import AuthConfig
+
+
+class SupabaseAuth(AuthBase):
+    """Supabase authentication provider using email/password."""
+    
+    def __init__(self, config: AuthConfig):
+        """Initialize Supabase authentication.
+        
+        Args:
+            config: Authentication configuration with Supabase credentials
+        """
+        super().__init__(config)
+        self._client: Client = None
+        self._session = None
+    
+    def _get_client(self) -> Client:
+        """Get or create Supabase client.
+        
+        Returns:
+            Supabase client instance
+            
+        Raises:
+            AuthenticationError: If client creation fails
+        """
+        if self._client is None:
+            try:
+                # Template substitution for environment variables
+                project_url = self._substitute_env_vars(self.config.project_url)
+                api_key = self._substitute_env_vars(self.config.api_key)
+                
+                self._client = create_client(project_url, api_key)
+            except Exception as e:
+                raise AuthenticationError(
+                    f"Failed to create Supabase client: {str(e)}", 
+                    "supabase"
+                )
+        
+        return self._client
+    
+    def _substitute_env_vars(self, value: str) -> str:
+        """Substitute environment variables in string values.
+        
+        Args:
+            value: String that may contain {{ env.VAR_NAME }} patterns
+            
+        Returns:
+            String with environment variables substituted
+        """
+        if not value:
+            return value
+        
+        # Simple template substitution for {{ env.VAR_NAME }}
+        import re
+        def replace_env_var(match):
+            var_name = match.group(1)
+            env_value = os.getenv(var_name)
+            if env_value is None:
+                raise ValueError(f"Environment variable {var_name} not found")
+            return env_value
+        
+        return re.sub(r'\{\{\s*env\.([A-Z_]+)\s*\}\}', replace_env_var, value)
+    
+    async def authenticate(self) -> str:
+        """Authenticate with Supabase using email/password.
+        
+        Returns:
+            Access token for API requests
+            
+        Raises:
+            AuthenticationError: If authentication fails
+        """
+        try:
+            client = self._get_client()
+            
+            # Substitute environment variables in credentials
+            email = self._substitute_env_vars(self.config.email)
+            password = self._substitute_env_vars(self.config.password)
+            
+            # Sign in with email/password
+            auth_response = client.auth.sign_in_with_password({
+                "email": email,
+                "password": password
+            })
+            
+            if not auth_response.session:
+                raise AuthenticationError(
+                    "No session returned from Supabase authentication",
+                    "supabase"
+                )
+            
+            self._session = auth_response.session
+            return auth_response.session.access_token
+            
+        except Exception as e:
+            if isinstance(e, AuthenticationError):
+                raise
+            raise AuthenticationError(
+                f"Supabase authentication failed: {str(e)}", 
+                "supabase"
+            )
+    
+    async def get_headers(self) -> Dict[str, str]:
+        """Get authentication headers for HTTP requests.
+        
+        Returns:
+            Dictionary with Authorization header
+        """
+        token = await self.token()
+        headers = {
+            "Authorization": f"Bearer {token}",
+            "Content-Type": "application/json",
+        }
+        
+        # Add any additional headers from config
+        if self.config.headers:
+            headers.update(self.config.headers)
+        
+        return headers
+    
+    def invalidate_token(self) -> None:
+        """Invalidate current session and token."""
+        super().invalidate_token()
+        self._session = None
+        
+        # Sign out from Supabase if we have a client
+        if self._client:
+            try:
+                self._client.auth.sign_out()
+            except Exception:
+                # Ignore errors during sign out
+                pass