ainative-python 2.0.0__py3-none-any.whl

ainative/agent_learning.py

@@ -0,0 +1,239 @@
+"""
+Agent Learning Module for AINative SDK
+
+Provides interface for agent learning, feedback, and performance tracking.
+"""
+
+from typing import TYPE_CHECKING, List, Dict, Any, Optional
+
+if TYPE_CHECKING:
+    from .client import AINativeClient
+
+
+class AgentLearningClient:
+    """Client for Agent Learning operations."""
+
+    def __init__(self, client: "AINativeClient"):
+        """
+        Initialize Agent Learning client.
+
+        Args:
+            client: Parent AINative client instance
+        """
+        self.client = client
+        self.base_path = "/agent-learning"
+
+    def record_interaction(
+        self,
+        agent_id: str,
+        interaction_type: str,
+        input_data: Dict[str, Any],
+        output_data: Dict[str, Any],
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Record an agent interaction for learning.
+
+        Args:
+            agent_id: Agent ID
+            interaction_type: Type of interaction
+            input_data: Input data for the interaction
+            output_data: Output/response data
+            metadata: Additional metadata
+
+        Returns:
+            Recorded interaction details
+        """
+        data = {
+            "agent_id": agent_id,
+            "interaction_type": interaction_type,
+            "input_data": input_data,
+            "output_data": output_data,
+            "metadata": metadata or {},
+        }
+
+        return self.client.post(f"{self.base_path}/interactions", data=data)
+
+    def get_interactions(
+        self,
+        agent_id: str,
+        interaction_type: Optional[str] = None,
+        limit: int = 100,
+        offset: int = 0,
+    ) -> Dict[str, Any]:
+        """
+        Get agent interactions.
+
+        Args:
+            agent_id: Agent ID
+            interaction_type: Filter by interaction type
+            limit: Maximum number of results
+            offset: Pagination offset
+
+        Returns:
+            List of interactions with pagination metadata
+        """
+        params = {
+            "agent_id": agent_id,
+            "limit": limit,
+            "offset": offset,
+        }
+
+        if interaction_type:
+            params["interaction_type"] = interaction_type
+
+        return self.client.get(f"{self.base_path}/interactions", params=params)
+
+    def submit_feedback(
+        self,
+        agent_id: str,
+        interaction_id: str,
+        rating: int,
+        feedback_type: str = "quality",
+        comments: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Submit feedback for an agent interaction.
+
+        Args:
+            agent_id: Agent ID
+            interaction_id: Interaction ID
+            rating: Feedback rating (1-5)
+            feedback_type: Type of feedback (quality, accuracy, speed, helpfulness)
+            comments: Optional feedback comments
+
+        Returns:
+            Feedback submission confirmation
+        """
+        data = {
+            "agent_id": agent_id,
+            "interaction_id": interaction_id,
+            "rating": rating,
+            "feedback_type": feedback_type,
+        }
+
+        if comments:
+            data["comments"] = comments
+
+        return self.client.post(f"{self.base_path}/feedback", data=data)
+
+    def get_feedback_summary(
+        self,
+        agent_id: str,
+        time_range: str = "7d",
+    ) -> Dict[str, Any]:
+        """
+        Get feedback summary for an agent.
+
+        Args:
+            agent_id: Agent ID
+            time_range: Time range (1d, 7d, 30d, 90d, all)
+
+        Returns:
+            Feedback summary statistics
+        """
+        params = {
+            "agent_id": agent_id,
+            "time_range": time_range,
+        }
+
+        return self.client.get(f"{self.base_path}/feedback/summary", params=params)
+
+    def get_performance_metrics(
+        self,
+        agent_id: str,
+        metric_types: Optional[List[str]] = None,
+        time_range: str = "7d",
+    ) -> Dict[str, Any]:
+        """
+        Get agent performance metrics.
+
+        Args:
+            agent_id: Agent ID
+            metric_types: Specific metric types to retrieve
+            time_range: Time range (1d, 7d, 30d, 90d, all)
+
+        Returns:
+            Performance metrics data
+        """
+        params = {
+            "agent_id": agent_id,
+            "time_range": time_range,
+        }
+
+        if metric_types:
+            params["metric_types"] = ",".join(metric_types)
+
+        return self.client.get(f"{self.base_path}/performance", params=params)
+
+    def compare_agents(
+        self,
+        agent_ids: List[str],
+        metrics: List[str],
+        time_range: str = "7d",
+    ) -> Dict[str, Any]:
+        """
+        Compare performance metrics across multiple agents.
+
+        Args:
+            agent_ids: List of agent IDs to compare
+            metrics: List of metrics to compare
+            time_range: Time range for comparison
+
+        Returns:
+            Comparative performance data
+        """
+        data = {
+            "agent_ids": agent_ids,
+            "metrics": metrics,
+            "time_range": time_range,
+        }
+
+        return self.client.post(f"{self.base_path}/compare", data=data)
+
+    def get_learning_progress(
+        self,
+        agent_id: str,
+    ) -> Dict[str, Any]:
+        """
+        Get agent learning progress and improvement trends.
+
+        Args:
+            agent_id: Agent ID
+
+        Returns:
+            Learning progress data
+        """
+        return self.client.get(f"{self.base_path}/agents/{agent_id}/progress")
+
+    def export_learning_data(
+        self,
+        agent_id: str,
+        format: str = "json",
+        include_raw_data: bool = False,
+    ) -> Dict[str, Any]:
+        """
+        Export agent learning data.
+
+        Args:
+            agent_id: Agent ID
+            format: Export format (json, csv, parquet)
+            include_raw_data: Include raw interaction data
+
+        Returns:
+            Export data or download URL
+        """
+        params = {
+            "format": format,
+            "include_raw_data": str(include_raw_data).lower(),
+        }
+
+        return self.client.get(
+            f"{self.base_path}/agents/{agent_id}/export",
+            params=params
+        )
+
+
+__all__ = [
+    "AgentLearningClient",
+]

ainative/agent_orchestration.py

@@ -0,0 +1,202 @@
+"""
+Agent Orchestration Module for AINative SDK
+
+Provides interface for orchestrating AI agent instances and tasks.
+"""
+
+from typing import TYPE_CHECKING, List, Dict, Any, Optional
+
+if TYPE_CHECKING:
+    from .client import AINativeClient
+
+
+class AgentOrchestrationClient:
+    """Client for Agent Orchestration operations."""
+
+    def __init__(self, client: "AINativeClient"):
+        """
+        Initialize Agent Orchestration client.
+
+        Args:
+            client: Parent AINative client instance
+        """
+        self.client = client
+        self.base_path = "/agent-orchestration"
+
+    def create_agent_instance(
+        self,
+        name: str,
+        agent_type: str,
+        capabilities: List[str],
+        config: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Create a new agent instance.
+
+        Args:
+            name: Agent instance name
+            agent_type: Type of agent (researcher, coder, reviewer, etc.)
+            capabilities: List of agent capabilities
+            config: Additional agent configuration
+
+        Returns:
+            Created agent instance details
+        """
+        data = {
+            "name": name,
+            "agent_type": agent_type,
+            "capabilities": capabilities,
+            "config": config or {},
+        }
+
+        return self.client.post(f"{self.base_path}/agents", data=data)
+
+    def list_agent_instances(
+        self,
+        agent_type: Optional[str] = None,
+        status: Optional[str] = None,
+        limit: int = 100,
+        offset: int = 0,
+    ) -> Dict[str, Any]:
+        """
+        List agent instances with optional filtering.
+
+        Args:
+            agent_type: Filter by agent type
+            status: Filter by status (active, idle, error)
+            limit: Maximum number of results
+            offset: Pagination offset
+
+        Returns:
+            List of agent instances with pagination metadata
+        """
+        params = {
+            "limit": limit,
+            "offset": offset,
+        }
+
+        if agent_type:
+            params["agent_type"] = agent_type
+        if status:
+            params["status"] = status
+
+        return self.client.get(f"{self.base_path}/agents", params=params)
+
+    def get_agent_instance(self, agent_id: str) -> Dict[str, Any]:
+        """
+        Get details of a specific agent instance.
+
+        Args:
+            agent_id: Agent instance ID
+
+        Returns:
+            Agent instance details
+        """
+        return self.client.get(f"{self.base_path}/agents/{agent_id}")
+
+    def create_task(
+        self,
+        agent_id: str,
+        task_type: str,
+        description: str,
+        context: Optional[Dict[str, Any]] = None,
+        priority: str = "medium",
+    ) -> Dict[str, Any]:
+        """
+        Create a new task for an agent instance.
+
+        Args:
+            agent_id: Agent instance ID
+            task_type: Type of task
+            description: Task description
+            context: Task context data
+            priority: Task priority (low, medium, high, critical)
+
+        Returns:
+            Created task details
+        """
+        data = {
+            "agent_id": agent_id,
+            "task_type": task_type,
+            "description": description,
+            "context": context or {},
+            "priority": priority,
+        }
+
+        return self.client.post(f"{self.base_path}/tasks", data=data)
+
+    def execute_task(
+        self,
+        task_id: str,
+        agent_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Execute a task.
+
+        Args:
+            task_id: Task ID to execute
+            agent_id: Optional specific agent to use
+
+        Returns:
+            Task execution result
+        """
+        data = {}
+        if agent_id:
+            data["agent_id"] = agent_id
+
+        return self.client.post(
+            f"{self.base_path}/tasks/{task_id}/execute",
+            data=data
+        )
+
+    def get_task_status(self, task_id: str) -> Dict[str, Any]:
+        """
+        Get task execution status.
+
+        Args:
+            task_id: Task ID
+
+        Returns:
+            Task status and progress details
+        """
+        return self.client.get(f"{self.base_path}/tasks/{task_id}/status")
+
+    def list_tasks(
+        self,
+        agent_id: Optional[str] = None,
+        status: Optional[str] = None,
+        task_type: Optional[str] = None,
+        limit: int = 100,
+        offset: int = 0,
+    ) -> Dict[str, Any]:
+        """
+        List tasks with optional filtering.
+
+        Args:
+            agent_id: Filter by agent instance
+            status: Filter by status (pending, running, completed, failed)
+            task_type: Filter by task type
+            limit: Maximum number of results
+            offset: Pagination offset
+
+        Returns:
+            List of tasks with pagination metadata
+        """
+        params = {
+            "limit": limit,
+            "offset": offset,
+        }
+
+        if agent_id:
+            params["agent_id"] = agent_id
+        if status:
+            params["status"] = status
+        if task_type:
+            params["task_type"] = task_type
+
+        return self.client.get(f"{self.base_path}/tasks", params=params)
+
+
+__all__ = [
+    "AgentOrchestrationClient",
+]

ainative/agent_state.py

@@ -0,0 +1,231 @@
+"""
+Agent State Module for AINative SDK
+
+Provides interface for agent state management, checkpoints, and recovery.
+"""
+
+from typing import TYPE_CHECKING, List, Dict, Any, Optional
+
+if TYPE_CHECKING:
+    from .client import AINativeClient
+
+
+class AgentStateClient:
+    """Client for Agent State operations."""
+
+    def __init__(self, client: "AINativeClient"):
+        """
+        Initialize Agent State client.
+
+        Args:
+            client: Parent AINative client instance
+        """
+        self.client = client
+        self.base_path = "/agent-state"
+
+    def create_state(
+        self,
+        agent_id: str,
+        state_data: Dict[str, Any],
+        state_type: str = "working",
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Create or update agent state.
+
+        Args:
+            agent_id: Agent ID
+            state_data: State data to store
+            state_type: Type of state (working, checkpoint, snapshot)
+            metadata: Additional metadata
+
+        Returns:
+            Created state details
+        """
+        data = {
+            "agent_id": agent_id,
+            "state_data": state_data,
+            "state_type": state_type,
+            "metadata": metadata or {},
+        }
+
+        return self.client.post(f"{self.base_path}/states", data=data)
+
+    def get_state(
+        self,
+        agent_id: str,
+        state_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Get agent state.
+
+        Args:
+            agent_id: Agent ID
+            state_id: Optional specific state ID (if not provided, returns latest)
+
+        Returns:
+            Agent state data
+        """
+        if state_id:
+            return self.client.get(f"{self.base_path}/states/{state_id}")
+        else:
+            params = {"agent_id": agent_id}
+            return self.client.get(f"{self.base_path}/states/latest", params=params)
+
+    def update_state(
+        self,
+        state_id: str,
+        state_data: Dict[str, Any],
+    ) -> Dict[str, Any]:
+        """
+        Update existing agent state.
+
+        Args:
+            state_id: State ID
+            state_data: Updated state data
+
+        Returns:
+            Updated state details
+        """
+        data = {
+            "state_data": state_data,
+        }
+
+        return self.client.put(f"{self.base_path}/states/{state_id}", data=data)
+
+    def delete_state(
+        self,
+        state_id: str,
+    ) -> Dict[str, Any]:
+        """
+        Delete agent state.
+
+        Args:
+            state_id: State ID to delete
+
+        Returns:
+            Deletion confirmation
+        """
+        return self.client.delete(f"{self.base_path}/states/{state_id}")
+
+    def list_states(
+        self,
+        agent_id: str,
+        state_type: Optional[str] = None,
+        limit: int = 100,
+        offset: int = 0,
+    ) -> Dict[str, Any]:
+        """
+        List agent states.
+
+        Args:
+            agent_id: Agent ID
+            state_type: Filter by state type
+            limit: Maximum number of results
+            offset: Pagination offset
+
+        Returns:
+            List of states with pagination metadata
+        """
+        params = {
+            "agent_id": agent_id,
+            "limit": limit,
+            "offset": offset,
+        }
+
+        if state_type:
+            params["state_type"] = state_type
+
+        return self.client.get(f"{self.base_path}/states", params=params)
+
+    def create_checkpoint(
+        self,
+        agent_id: str,
+        checkpoint_name: str,
+        state_data: Dict[str, Any],
+        description: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Create a state checkpoint for recovery.
+
+        Args:
+            agent_id: Agent ID
+            checkpoint_name: Checkpoint name
+            state_data: State data to checkpoint
+            description: Optional checkpoint description
+
+        Returns:
+            Created checkpoint details
+        """
+        data = {
+            "agent_id": agent_id,
+            "checkpoint_name": checkpoint_name,
+            "state_data": state_data,
+        }
+
+        if description:
+            data["description"] = description
+
+        return self.client.post(f"{self.base_path}/checkpoints", data=data)
+
+    def restore_checkpoint(
+        self,
+        checkpoint_id: str,
+    ) -> Dict[str, Any]:
+        """
+        Restore agent state from a checkpoint.
+
+        Args:
+            checkpoint_id: Checkpoint ID to restore
+
+        Returns:
+            Restored state data
+        """
+        return self.client.post(
+            f"{self.base_path}/checkpoints/{checkpoint_id}/restore"
+        )
+
+    def list_checkpoints(
+        self,
+        agent_id: str,
+        limit: int = 100,
+        offset: int = 0,
+    ) -> Dict[str, Any]:
+        """
+        List agent checkpoints.
+
+        Args:
+            agent_id: Agent ID
+            limit: Maximum number of results
+            offset: Pagination offset
+
+        Returns:
+            List of checkpoints with pagination metadata
+        """
+        params = {
+            "agent_id": agent_id,
+            "limit": limit,
+            "offset": offset,
+        }
+
+        return self.client.get(f"{self.base_path}/checkpoints", params=params)
+
+    def delete_checkpoint(
+        self,
+        checkpoint_id: str,
+    ) -> Dict[str, Any]:
+        """
+        Delete a checkpoint.
+
+        Args:
+            checkpoint_id: Checkpoint ID to delete
+
+        Returns:
+            Deletion confirmation
+        """
+        return self.client.delete(f"{self.base_path}/checkpoints/{checkpoint_id}")
+
+
+__all__ = [
+    "AgentStateClient",
+]