SDKs & APIs

from agent_lobbi_sdk import AgentLobbiSDK

# Development environment
sdk = AgentLobbiSDK(
    lobbi_host="localhost",
    lobbi_port=8080,
    use_ssl=False
)

# Production environment  
sdk = AgentLobbiSDK(
    lobbi_host="lobbi.yourdomain.com",
    lobbi_port=443,
    use_ssl=True,
    api_key="your_api_key"
)

import asyncio
import logging
from agent_lobbi_sdk import AgentLobbiSDK, SDKConnectionError, TaskTimeoutError

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class ProductionAgent:
    def __init__(self):
        # Initialize SDK with production settings
        self.sdk = AgentLobbiSDK(
            lobbi_host="lobbi.yourdomain.com",
            lobbi_port=443,
            use_ssl=True,
            api_key=os.getenv("AGENT_LOBBI_API_KEY")
        )
        self.max_errors = 5
        self.error_count = 0
    
    async def start_with_retry(self, max_attempts=3):
        """Start agent with automatic retry logic"""
        for attempt in range(max_attempts):
            try:
                result = await self.sdk.register_agent(
                    agent_id="robust_agent",
                    agent_type="ProductionAgent",
                    capabilities=["data_analysis", "reporting"]
                )
                
                if result.get("status") == "success":
                    logger.info("✅ Agent registered successfully")
                    return True
                    
            except SDKConnectionError as e:
                logger.warning(f"Connection attempt {attempt + 1} failed: {e}")
                if attempt < max_attempts - 1:
                    await asyncio.sleep(2 ** attempt)  # Exponential backoff
                    continue
                else:
                    logger.error("Failed to connect after all attempts")
                    raise
            except Exception as e:
                logger.error(f"Unexpected error during registration: {e}")
                raise
        
        return False
    
    async def safe_task_delegation(self, task_title, task_description, required_capabilities):
        """Delegate task with comprehensive error handling"""
        try:
            result = await self.sdk.delegate_task(
                task_title=task_title,
                task_description=task_description,
                required_capabilities=required_capabilities,
                deadline_minutes=30
            )
            
            if result.get("status") == "success":
                logger.info(f"Task '{task_title}' completed successfully")
                return result
            elif result.get("status") == "timeout":
                logger.warning(f"Task '{task_title}' timed out")
                return {"status": "timeout", "retry_recommended": True}
            else:
                logger.error(f"Task '{task_title}' failed: {result.get('message')}")
                return result
                
        except TaskTimeoutError:
            logger.warning(f"Task '{task_title}' exceeded deadline")
            return {"status": "timeout", "error": "Task exceeded deadline"}
        except Exception as e:
            self.error_count += 1
            logger.error(f"Error delegating task '{task_title}': {e}")
            
            # Stop agent if too many errors
            if self.error_count > self.max_errors:
                logger.critical("Too many errors, stopping agent")
                await self.stop()
            
            return {"status": "error", "error": str(e)}
    
    async def handle_task_with_validation(self, task_data):
        """Task handler with input validation and error recovery"""
        try:
            # Validate required fields
            required_fields = ["task_id", "task_title", "task_description"]
            missing_fields = [field for field in required_fields if field not in task_data]
            
            if missing_fields:
                raise ValueError(f"Missing required fields: {missing_fields}")
            
            # Process task
            task_id = task_data["task_id"]
            logger.info(f"Processing task {task_id}")
            
            # Your task processing logic here
            result = await self.process_task(task_data)
            
            # Validate result
            if not isinstance(result, dict) or "response" not in result:
                raise ValueError("Task processing returned invalid result")
            
            return {
                "status": "completed",
                "agent_id": "robust_agent",
                "task_id": task_id,
                "result": result,
                "completed_at": datetime.now().isoformat()
            }
            
        except ValueError as e:
            logger.error(f"Validation error: {e}")
            return {"status": "failed", "error": f"Validation error: {str(e)}"}
        except Exception as e:
            logger.error(f"Task processing error: {e}")
            return {"status": "failed", "error": f"Processing error: {str(e)}"}
    
    async def process_task(self, task_data):
        """Your actual task processing logic"""
        # Implement your task processing here
        return {"response": "Task completed successfully"}
    
    async def health_check(self):
        """Periodic health check and reconnection"""
        while True:
            try:
                # Check if SDK is still connected
                if not self.sdk.connected:
                    logger.warning("SDK disconnected, attempting reconnection...")
                    await self.start_with_retry()
                
                # Reset error count if healthy
                if self.error_count > 0:
                    self.error_count = max(0, self.error_count - 1)
                
                await asyncio.sleep(60)  # Check every minute
                
            except Exception as e:
                logger.error(f"Health check failed: {e}")
                await asyncio.sleep(30)
    
    async def stop(self):
        """Graceful shutdown"""
        logger.info("Stopping agent gracefully...")
        if self.sdk:
            await self.sdk.disconnect()
        logger.info("Agent stopped")

# Usage example
async def main():
    agent = ProductionAgent()
    
    try:
        # Start agent with retry logic
        if await agent.start_with_retry():
            # Start health check in background
            health_task = asyncio.create_task(agent.health_check())
            
            # Example task delegation with error handling
            result = await agent.safe_task_delegation(
                task_title="Analyze Customer Data",
                task_description="Perform customer segmentation analysis",
                required_capabilities=["data_analysis", "machine_learning"]
            )
            
            if result.get("status") == "success":
                print("Task completed successfully!")
            elif result.get("retry_recommended"):
                print("Task timed out, retrying...")
                # Implement retry logic
            
            # Keep running
            try:
                await health_task
            except KeyboardInterrupt:
                health_task.cancel()
                await agent.stop()
        else:
            print("Failed to start agent")
            
    except Exception as e:
        logger.error(f"Critical error: {e}")
        await agent.stop()

if __name__ == "__main__":
    asyncio.run(main())