ainative-python 2.0.0__py3-none-any.whl

ainative/agent_swarm/__init__.py

@@ -0,0 +1,510 @@
+"""
+Agent Swarm Module for AINative SDK
+
+Provides interface for orchestrating and managing AI agent swarms.
+"""
+
+from typing import TYPE_CHECKING, List, Dict, Any, Optional
+from enum import Enum
+
+if TYPE_CHECKING:
+    from ..client import AINativeClient
+
+
+class AgentType(Enum):
+    """Types of agents available in the swarm."""
+    RESEARCHER = "researcher"
+    CODER = "coder"
+    REVIEWER = "reviewer"
+    TESTER = "tester"
+    DOCUMENTER = "documenter"
+    ANALYST = "analyst"
+    DESIGNER = "designer"
+    ORCHESTRATOR = "orchestrator"
+
+
+class SwarmStatus(Enum):
+    """Status of agent swarm."""
+    IDLE = "idle"
+    STARTING = "starting"
+    RUNNING = "running"
+    PAUSED = "paused"
+    STOPPING = "stopping"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+
+class AgentSwarmClient:
+    """Main client for Agent Swarm operations."""
+    
+    def __init__(self, client: "AINativeClient"):
+        """
+        Initialize Agent Swarm client.
+        
+        Args:
+            client: Parent AINative client instance
+        """
+        self.client = client
+        self.base_path = "/agent-swarm"
+    
+    def start_swarm(
+        self,
+        project_id: str,
+        agents: List[Dict[str, Any]],
+        objective: str,
+        config: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Start a new agent swarm.
+        
+        Args:
+            project_id: Project ID
+            agents: List of agent configurations
+            objective: Swarm objective/goal
+            config: Additional swarm configuration
+        
+        Returns:
+            Swarm initialization details
+        """
+        data = {
+            "project_id": project_id,
+            "agents": agents,
+            "objective": objective,
+            "config": config or {},
+        }
+        
+        return self.client.post(f"{self.base_path}/start", data=data)
+    
+    def orchestrate(
+        self,
+        swarm_id: str,
+        task: str,
+        context: Optional[Dict[str, Any]] = None,
+        agents: Optional[List[str]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Orchestrate agents for a specific task.
+        
+        Args:
+            swarm_id: Swarm ID
+            task: Task description
+            context: Task context
+            agents: Specific agents to use (optional)
+        
+        Returns:
+            Orchestration result
+        """
+        data = {
+            "swarm_id": swarm_id,
+            "task": task,
+            "context": context or {},
+        }
+        
+        if agents:
+            data["agents"] = agents
+        
+        return self.client.post(f"{self.base_path}/orchestrate", data=data)
+    
+    def get_status(self, swarm_id: str) -> Dict[str, Any]:
+        """
+        Get swarm status.
+        
+        Args:
+            swarm_id: Swarm ID
+        
+        Returns:
+            Swarm status details
+        """
+        return self.client.get(f"{self.base_path}/{swarm_id}/status")
+    
+    def get_metrics(
+        self,
+        swarm_id: Optional[str] = None,
+        project_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Get swarm performance metrics.
+        
+        Args:
+            swarm_id: Optional swarm ID filter
+            project_id: Optional project ID filter
+        
+        Returns:
+            Swarm metrics
+        """
+        params = {}
+        if swarm_id:
+            params["swarm_id"] = swarm_id
+        if project_id:
+            params["project_id"] = project_id
+        
+        return self.client.get(f"{self.base_path}/metrics", params=params)
+    
+    def get_agent_types(self) -> List[Dict[str, Any]]:
+        """
+        Get available agent types and their capabilities.
+        
+        Returns:
+            List of agent types with descriptions
+        """
+        response = self.client.get(f"{self.base_path}/agent-types")
+        return response.get("agent_types", [])
+    
+    def configure_agent(
+        self,
+        swarm_id: str,
+        agent_id: str,
+        config: Dict[str, Any],
+    ) -> Dict[str, Any]:
+        """
+        Configure a specific agent.
+        
+        Args:
+            swarm_id: Swarm ID
+            agent_id: Agent ID
+            config: Agent configuration
+        
+        Returns:
+            Configuration result
+        """
+        return self.client.put(
+            f"{self.base_path}/{swarm_id}/agents/{agent_id}/config",
+            data=config
+        )
+    
+    def set_agent_prompt(
+        self,
+        swarm_id: str,
+        agent_id: str,
+        prompt: str,
+        system_prompt: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Set agent prompt configuration.
+        
+        Args:
+            swarm_id: Swarm ID
+            agent_id: Agent ID
+            prompt: Main prompt
+            system_prompt: System prompt (optional)
+        
+        Returns:
+            Prompt configuration result
+        """
+        data = {"prompt": prompt}
+        if system_prompt:
+            data["system_prompt"] = system_prompt
+        
+        return self.client.post(
+            f"{self.base_path}/{swarm_id}/agents/{agent_id}/prompt",
+            data=data
+        )
+    
+    def stop_swarm(self, swarm_id: str, force: bool = False) -> Dict[str, Any]:
+        """
+        Stop an agent swarm.
+        
+        Args:
+            swarm_id: Swarm ID
+            force: Force stop without cleanup
+        
+        Returns:
+            Stop confirmation
+        """
+        data = {"force": force}
+        return self.client.post(f"{self.base_path}/{swarm_id}/stop", data=data)
+    
+    def pause_swarm(self, swarm_id: str) -> Dict[str, Any]:
+        """
+        Pause an agent swarm.
+        
+        Args:
+            swarm_id: Swarm ID
+        
+        Returns:
+            Pause confirmation
+        """
+        return self.client.post(f"{self.base_path}/{swarm_id}/pause")
+    
+    def resume_swarm(self, swarm_id: str) -> Dict[str, Any]:
+        """
+        Resume a paused swarm.
+        
+        Args:
+            swarm_id: Swarm ID
+        
+        Returns:
+            Resume confirmation
+        """
+        return self.client.post(f"{self.base_path}/{swarm_id}/resume")
+    
+    def get_swarm_history(
+        self,
+        swarm_id: str,
+        limit: int = 100,
+    ) -> List[Dict[str, Any]]:
+        """
+        Get swarm execution history.
+        
+        Args:
+            swarm_id: Swarm ID
+            limit: Maximum number of history entries
+        
+        Returns:
+            List of history entries
+        """
+        params = {"limit": limit}
+        response = self.client.get(
+            f"{self.base_path}/{swarm_id}/history",
+            params=params
+        )
+        return response.get("history", [])
+    
+    def get_agent_communications(
+        self,
+        swarm_id: str,
+        agent_id: Optional[str] = None,
+    ) -> List[Dict[str, Any]]:
+        """
+        Get agent communication logs.
+        
+        Args:
+            swarm_id: Swarm ID
+            agent_id: Optional specific agent ID
+        
+        Returns:
+            List of communication entries
+        """
+        params = {}
+        if agent_id:
+            params["agent_id"] = agent_id
+        
+        response = self.client.get(
+            f"{self.base_path}/{swarm_id}/communications",
+            params=params
+        )
+        return response.get("communications", [])
+    
+    def create_agent(
+        self,
+        name: str,
+        agent_type: AgentType,
+        capabilities: List[str],
+        prompt: str,
+        config: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Create a custom agent template.
+
+        Args:
+            name: Agent name
+            agent_type: Type of agent
+            capabilities: List of capabilities
+            prompt: Agent prompt
+            config: Additional configuration
+
+        Returns:
+            Created agent details
+        """
+        data = {
+            "name": name,
+            "type": agent_type.value,
+            "capabilities": capabilities,
+            "prompt": prompt,
+            "config": config or {},
+        }
+
+        return self.client.post(f"{self.base_path}/agents", data=data)
+
+    def list_swarms(
+        self,
+        project_id: Optional[str] = None,
+        status: Optional[str] = None,
+        limit: int = 100,
+        offset: int = 0,
+    ) -> Dict[str, Any]:
+        """
+        List all swarms with optional filtering.
+
+        Args:
+            project_id: Filter by project ID
+            status: Filter by status
+            limit: Maximum number of results
+            offset: Pagination offset
+
+        Returns:
+            List of swarms with pagination metadata
+        """
+        params = {
+            "limit": limit,
+            "offset": offset,
+        }
+
+        if project_id:
+            params["project_id"] = project_id
+        if status:
+            params["status"] = status
+
+        return self.client.get(self.base_path, params=params)
+
+    def delete_swarm(self, swarm_id: str, force: bool = False) -> Dict[str, Any]:
+        """
+        Delete a swarm.
+
+        Args:
+            swarm_id: Swarm ID to delete
+            force: Force deletion without cleanup
+
+        Returns:
+            Deletion confirmation
+        """
+        params = {"force": str(force).lower()}
+        return self.client.delete(f"{self.base_path}/{swarm_id}", params=params)
+
+    def scale_swarm(
+        self,
+        swarm_id: str,
+        agent_counts: Dict[str, int],
+    ) -> Dict[str, Any]:
+        """
+        Scale swarm by adjusting agent counts.
+
+        Args:
+            swarm_id: Swarm ID
+            agent_counts: Dictionary mapping agent types to desired counts
+
+        Returns:
+            Scaling operation result
+        """
+        data = {"agent_counts": agent_counts}
+        return self.client.post(f"{self.base_path}/{swarm_id}/scale", data=data)
+
+    def get_analytics(
+        self,
+        swarm_id: str,
+        metric_types: Optional[List[str]] = None,
+        time_range: str = "7d",
+    ) -> Dict[str, Any]:
+        """
+        Get swarm analytics and performance metrics.
+
+        Args:
+            swarm_id: Swarm ID
+            metric_types: Specific metrics to retrieve
+            time_range: Time range (1d, 7d, 30d, all)
+
+        Returns:
+            Analytics data
+        """
+        params = {"time_range": time_range}
+
+        if metric_types:
+            params["metric_types"] = ",".join(metric_types)
+
+        return self.client.get(f"{self.base_path}/{swarm_id}/analytics", params=params)
+
+    def execute_parallel_tasks(
+        self,
+        swarm_id: str,
+        tasks: List[Dict[str, Any]],
+        max_concurrency: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        """
+        Execute multiple tasks in parallel across swarm.
+
+        Args:
+            swarm_id: Swarm ID
+            tasks: List of task definitions
+            max_concurrency: Maximum concurrent executions
+
+        Returns:
+            Parallel execution results
+        """
+        data = {
+            "tasks": tasks,
+        }
+
+        if max_concurrency:
+            data["max_concurrency"] = max_concurrency
+
+        return self.client.post(
+            f"{self.base_path}/{swarm_id}/tasks/parallel",
+            data=data
+        )
+
+    def get_swarm_health(self, swarm_id: str) -> Dict[str, Any]:
+        """
+        Get swarm health status.
+
+        Args:
+            swarm_id: Swarm ID
+
+        Returns:
+            Health status details
+        """
+        return self.client.get(f"{self.base_path}/{swarm_id}/health")
+
+    def update_swarm_config(
+        self,
+        swarm_id: str,
+        config: Dict[str, Any],
+    ) -> Dict[str, Any]:
+        """
+        Update swarm configuration.
+
+        Args:
+            swarm_id: Swarm ID
+            config: New configuration settings
+
+        Returns:
+            Updated configuration
+        """
+        return self.client.put(f"{self.base_path}/{swarm_id}/config", data=config)
+
+    def get_agent_status(
+        self,
+        swarm_id: str,
+        agent_id: str,
+    ) -> Dict[str, Any]:
+        """
+        Get detailed status of a specific agent in the swarm.
+
+        Args:
+            swarm_id: Swarm ID
+            agent_id: Agent ID
+
+        Returns:
+            Agent status details
+        """
+        return self.client.get(f"{self.base_path}/{swarm_id}/agents/{agent_id}/status")
+
+    def broadcast_message(
+        self,
+        swarm_id: str,
+        message: str,
+        target_agents: Optional[List[str]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Broadcast a message to all or specific agents in swarm.
+
+        Args:
+            swarm_id: Swarm ID
+            message: Message to broadcast
+            target_agents: Optional list of specific agent IDs
+
+        Returns:
+            Broadcast confirmation
+        """
+        data = {"message": message}
+
+        if target_agents:
+            data["target_agents"] = target_agents
+
+        return self.client.post(f"{self.base_path}/{swarm_id}/broadcast", data=data)
+
+
+__all__ = [
+    "AgentSwarmClient",
+    "AgentType",
+    "SwarmStatus",
+]

ainative/auth.py

@@ -0,0 +1,113 @@
+"""
+AINative SDK Authentication Module
+
+Handles API key authentication and authorization for AINative Studio APIs.
+"""
+
+import os
+from typing import Optional, Dict, Any
+from dataclasses import dataclass
+import time
+import hashlib
+import hmac
+import base64
+
+
+@dataclass
+class AuthConfig:
+    """Configuration for authentication."""
+    
+    api_key: Optional[str] = None
+    api_secret: Optional[str] = None
+    environment: str = "production"
+    auto_refresh: bool = True
+    timeout: int = 30
+    
+    def __post_init__(self):
+        """Load from environment variables if not provided."""
+        if not self.api_key:
+            self.api_key = os.getenv("AINATIVE_API_KEY")
+        if not self.api_secret:
+            self.api_secret = os.getenv("AINATIVE_API_SECRET")
+        
+        # Validate environment
+        valid_environments = ["production", "staging", "development", "local"]
+        if self.environment not in valid_environments:
+            raise ValueError(f"Invalid environment: {self.environment}")
+    
+    @property
+    def is_configured(self) -> bool:
+        """Check if authentication is properly configured."""
+        return bool(self.api_key)
+
+
+class APIKeyAuth:
+    """Handles API key authentication for requests."""
+    
+    def __init__(self, config: AuthConfig):
+        self.config = config
+        self._token_cache: Optional[Dict[str, Any]] = None
+        self._token_expiry: float = 0
+    
+    def get_headers(self) -> Dict[str, str]:
+        """Get authentication headers for API requests."""
+        if not self.config.api_key:
+            raise ValueError("API key not configured")
+        
+        headers = {
+            "X-API-Key": self.config.api_key,
+            "X-SDK-Version": "0.1.0",
+            "X-SDK-Language": "Python",
+        }
+        
+        # Add signature if API secret is provided
+        if self.config.api_secret:
+            timestamp = str(int(time.time()))
+            signature = self._generate_signature(timestamp)
+            headers.update({
+                "X-Timestamp": timestamp,
+                "X-Signature": signature,
+            })
+        
+        return headers
+    
+    def _generate_signature(self, timestamp: str) -> str:
+        """Generate HMAC signature for request."""
+        message = f"{self.config.api_key}{timestamp}"
+        signature = hmac.new(
+            self.config.api_secret.encode(),
+            message.encode(),
+            hashlib.sha256
+        ).digest()
+        return base64.b64encode(signature).decode()
+    
+    def get_bearer_token(self) -> Optional[str]:
+        """Get Bearer token if using OAuth flow (future enhancement)."""
+        # Placeholder for future OAuth implementation
+        return None
+    
+    def validate_credentials(self) -> bool:
+        """Validate that credentials are properly configured."""
+        return self.config.is_configured
+    
+    def refresh_token(self) -> bool:
+        """Refresh authentication token if needed (future enhancement)."""
+        # Placeholder for future token refresh logic
+        return True
+
+
+class MultiTenantAuth(APIKeyAuth):
+    """Extended authentication for multi-tenant scenarios."""
+    
+    def __init__(self, config: AuthConfig, organization_id: Optional[str] = None):
+        super().__init__(config)
+        self.organization_id = organization_id or os.getenv("AINATIVE_ORG_ID")
+    
+    def get_headers(self) -> Dict[str, str]:
+        """Get headers including organization context."""
+        headers = super().get_headers()
+        
+        if self.organization_id:
+            headers["X-Organization-ID"] = self.organization_id
+        
+        return headers