aegis-stack 0.2.0rc2__py3-none-any.whl

aegis/templates/cookiecutter-aegis-project/{{cookiecutter.project_slug}}/app/services/ai/service.py

@@ -0,0 +1,388 @@
+"""
+AI service core implementation using PydanticAI.
+
+This module provides the main AIService class that handles AI chat functionality,
+conversation management, and provider integration.
+"""
+
+import uuid
+from collections.abc import AsyncIterator
+from datetime import UTC, datetime
+from typing import Any
+
+from pydantic_ai.exceptions import ModelRetry, UnexpectedModelBehavior
+
+from app.core.log import logger
+
+from .config import get_ai_config
+from .conversation import ConversationManager
+from .models import (
+    Conversation,
+    ConversationMessage,
+    MessageRole,
+    StreamingConversation,
+    StreamingMessage,
+)
+from .providers import get_agent
+
+
+class AIServiceError(Exception):
+    """Base exception for AI service errors."""
+
+    pass
+
+
+class ProviderError(AIServiceError):
+    """Exception raised when AI provider fails."""
+
+    pass
+
+
+class ConversationError(AIServiceError):
+    """Exception raised when conversation management fails."""
+
+    pass
+
+
+class AIService:
+    """
+    Core AI service using PydanticAI for chat functionality.
+
+    Handles chat completions, conversation management, and provider abstraction.
+    Creates Agent instances per request for simplicity and resource efficiency.
+    """
+
+    def __init__(self, settings: Any):
+        """Initialize AI service with configuration."""
+        self.settings = settings
+        self.config = get_ai_config(settings)
+        self.conversation_manager = ConversationManager()
+
+        # logger.info(
+        #     f"AI service initialized - Provider: {self.config.provider}, "
+        #     f"Enabled: {self.config.enabled}"
+        # )
+
+    async def chat(
+        self, message: str, conversation_id: str | None = None, user_id: str = "default"
+    ) -> ConversationMessage:
+        """
+        Send a chat message and get AI response.
+
+        Args:
+            message: The user's message
+            conversation_id: Optional conversation ID (creates new if None)
+            user_id: User identifier for conversation ownership
+
+        Returns:
+            ConversationMessage: The AI's response message
+
+        Raises:
+            AIServiceError: If service is disabled or not configured
+            ProviderError: If AI provider fails
+            ConversationError: If conversation management fails
+        """
+        if not self.config.enabled:
+            raise AIServiceError("AI service is disabled")
+
+        try:
+            # Setup conversation and add user message
+            conversation = self._setup_conversation(message, conversation_id, user_id)
+
+            # Prepare agent and conversation context
+            agent, conversation_context = self._prepare_agent_and_context(conversation)
+
+            # Get AI response
+            start_time = datetime.now(UTC)
+            result = await agent.run(conversation_context)
+            end_time = datetime.now(UTC)
+            response_time_ms = (end_time - start_time).total_seconds() * 1000
+
+            # Add AI response to conversation
+            ai_message = conversation.add_message(
+                MessageRole.ASSISTANT, result.output, message_id=str(uuid.uuid4())
+            )
+
+            # Store conversation ID in message metadata for easy lookup
+            ai_message.metadata["conversation_id"] = conversation.id
+
+            # Finalize conversation (update metadata and save)
+            self._finalize_conversation(conversation, response_time_ms)
+
+            return ai_message
+
+        except (ModelRetry, UnexpectedModelBehavior) as e:
+            error_msg = f"AI provider error: {e}"
+            logger.error(error_msg)
+            raise ProviderError(error_msg) from e
+        except Exception as e:
+            error_msg = f"Chat processing failed: {e}"
+            logger.error(error_msg)
+            raise AIServiceError(error_msg) from e
+
+    async def stream_chat(
+        self,
+        message: str,
+        conversation_id: str | None = None,
+        user_id: str = "default",
+        stream_delta: bool = False,
+    ) -> AsyncIterator[StreamingMessage]:
+        """
+        Stream a chat message with real-time response generation.
+
+        Args:
+            message: The user's message
+            conversation_id: Optional conversation ID (creates new if None)
+            user_id: User identifier for conversation ownership
+            stream_delta: Whether to stream delta changes or full content
+
+        Yields:
+            StreamingMessage: Real-time message chunks
+
+        Raises:
+            AIServiceError: If service is disabled or not configured
+            ProviderError: If AI provider fails
+            ConversationError: If conversation management fails
+        """
+        if not self.config.enabled:
+            raise AIServiceError("AI service is disabled")
+
+        try:
+            # Setup conversation and add user message
+            conversation = self._setup_conversation(message, conversation_id, user_id)
+
+            # Create streaming conversation wrapper
+            streaming_conv = StreamingConversation(conversation=conversation)
+            streaming_conv.reset_stream()
+
+            # Prepare agent and conversation context
+            agent, conversation_context = self._prepare_agent_and_context(conversation)
+
+            # Start streaming
+            start_time = datetime.now(UTC)
+
+            # Generate a message ID for the streaming response
+            message_id = str(uuid.uuid4())
+
+            # Use PydanticAI's run_stream method for streaming
+            async with agent.run_stream(conversation_context) as result:
+                # Stream text chunks
+                async for text_chunk in result.stream_text(delta=stream_delta):
+                    # Accumulate content
+                    total_content = streaming_conv.accumulate_content(
+                        text_chunk, is_delta=stream_delta
+                    )
+
+                    # Yield streaming message chunk
+                    yield StreamingMessage(
+                        content=text_chunk if stream_delta else total_content,
+                        is_final=False,
+                        is_delta=stream_delta,
+                        message_id=message_id,
+                        conversation_id=conversation.id,
+                        metadata={
+                            "provider": self.config.provider,
+                            "model": self.config.model,
+                            "stream_delta": stream_delta,
+                        },
+                    )
+
+            end_time = datetime.now(UTC)
+            response_time_ms = (end_time - start_time).total_seconds() * 1000
+
+            # Add final message to conversation using accumulated streaming content
+            final_content = streaming_conv.accumulated_content or "No content received"
+            ai_message = conversation.add_message(
+                MessageRole.ASSISTANT, final_content, message_id=message_id
+            )
+
+            # Store conversation metadata
+            ai_message.metadata["conversation_id"] = conversation.id
+
+            # Finalize conversation (update metadata and save)
+            self._finalize_conversation(
+                conversation, response_time_ms, is_streaming=True
+            )
+
+            # Yield final streaming message
+            yield StreamingMessage(
+                content=final_content,
+                is_final=True,
+                is_delta=False,
+                message_id=message_id,
+                conversation_id=conversation.id,
+                metadata={
+                    "provider": self.config.provider,
+                    "model": self.config.model,
+                    "response_time_ms": response_time_ms,
+                    "stream_complete": True,
+                },
+            )
+
+        except (ModelRetry, UnexpectedModelBehavior) as e:
+            error_msg = f"AI provider streaming error: {e}"
+            logger.error(error_msg)
+            raise ProviderError(error_msg) from e
+        except Exception as e:
+            error_msg = f"Streaming failed: {e}"
+            logger.error(error_msg)
+            raise AIServiceError(error_msg) from e
+
+    def _setup_conversation(
+        self,
+        message: str,
+        conversation_id: str | None,
+        user_id: str,
+    ) -> Conversation:
+        """
+        Get or create conversation and add user message.
+
+        Args:
+            message: The user's message
+            conversation_id: Optional conversation ID (creates new if None)
+            user_id: User identifier for conversation ownership
+
+        Returns:
+            Conversation: The conversation with user message added
+
+        Raises:
+            ConversationError: If conversation_id provided but not found
+        """
+        # Get or create conversation
+        if conversation_id:
+            conversation = self.conversation_manager.get_conversation(conversation_id)
+            if not conversation:
+                raise ConversationError(f"Conversation {conversation_id} not found")
+        else:
+            conversation = self.conversation_manager.create_conversation(
+                provider=self.config.provider,
+                model=self.config.model,
+                user_id=user_id,
+            )
+
+        # Add user message to conversation
+        conversation.add_message(MessageRole.USER, message)
+
+        return conversation
+
+    def _prepare_agent_and_context(self, conversation: Conversation) -> tuple[Any, str]:
+        """
+        Create agent for request and build conversation context.
+
+        Args:
+            conversation: The conversation to prepare context from
+
+        Returns:
+            tuple[Any, str]: (agent instance, conversation context string)
+        """
+        # Create agent for this request
+        agent = get_agent(self.config, self.settings)
+
+        # Build conversation context for AI
+        conversation_context = self._build_conversation_context(conversation)
+
+        return agent, conversation_context
+
+    def _finalize_conversation(
+        self,
+        conversation: Conversation,
+        response_time_ms: float,
+        is_streaming: bool = False,
+    ) -> None:
+        """
+        Update conversation metadata and save.
+
+        Args:
+            conversation: The conversation to finalize
+            response_time_ms: Response time in milliseconds
+            is_streaming: Whether this was a streaming response
+        """
+        # Update conversation metadata
+        metadata_update = {
+            "last_response_time_ms": response_time_ms,
+            "total_messages": conversation.get_message_count(),
+            "last_activity": datetime.now(UTC).isoformat(),
+        }
+
+        if is_streaming:
+            metadata_update["streaming"] = True
+
+        conversation.metadata.update(metadata_update)
+
+        # Save conversation
+        self.conversation_manager.save_conversation(conversation)
+
+    def _build_conversation_context(self, conversation: Conversation) -> str:
+        """
+        Build conversation context for AI from message history.
+
+        Args:
+            conversation: The conversation with message history
+
+        Returns:
+            str: Formatted conversation context for AI
+        """
+        if not conversation.messages:
+            return ""
+
+        # For continuous conversation, include recent message history
+        # Limit to last 10 messages to manage context window
+        recent_messages = conversation.messages[-10:]
+
+        # Format messages for context
+        context_parts = []
+        for msg in recent_messages[:-1]:  # Exclude the latest message (just added)
+            if msg.role == MessageRole.USER:
+                context_parts.append(f"User: {msg.content}")
+            elif msg.role == MessageRole.ASSISTANT:
+                context_parts.append(f"Assistant: {msg.content}")
+
+        # Add the current user message
+        latest_message = conversation.get_last_message()
+        if latest_message and latest_message.role == MessageRole.USER:
+            if context_parts:
+                # Include conversation history + current message
+                return "\n".join(context_parts) + f"\n\nUser: {latest_message.content}"
+            else:
+                # First message in conversation
+                return latest_message.content
+
+        return ""
+
+    def get_conversation(self, conversation_id: str) -> Conversation | None:
+        """Get a conversation by ID."""
+        return self.conversation_manager.get_conversation(conversation_id)
+
+    def list_conversations(self, user_id: str = "default") -> list[Conversation]:
+        """List all conversations for a user."""
+        return self.conversation_manager.list_conversations(user_id)
+
+    def get_service_status(self) -> dict[str, Any]:
+        """Get current service status and metrics."""
+        total_conversations = len(self.conversation_manager.conversations)
+
+        return {
+            "enabled": self.config.enabled,
+            "provider": self.config.provider,
+            "model": self.config.model,
+            "agent_initialized": True,  # Agents created per request, always available
+            "total_conversations": total_conversations,
+            "configuration_valid": len(
+                self.config.validate_configuration(self.settings)
+            )
+            == 0,
+        }
+
+    def validate_service(self) -> list[str]:
+        """Validate service configuration and return any issues."""
+        errors = []
+
+        # Check configuration
+        config_errors = self.config.validate_configuration(self.settings)
+        errors.extend(config_errors)
+
+        # Check agent initialization (agents created per request,
+        # always available when enabled)
+        # No persistent agent check needed in agent-per-request pattern
+
+        return errors

aegis/templates/cookiecutter-aegis-project/{{cookiecutter.project_slug}}/app/services/auth/__init__.py

@@ -0,0 +1 @@
+"""Authentication services."""

aegis/templates/cookiecutter-aegis-project/{{cookiecutter.project_slug}}/app/services/auth/auth_service.py

@@ -0,0 +1,41 @@
+"""Authentication service utilities."""
+
+from fastapi import HTTPException, status
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+from app.core.security import verify_token
+from app.models.user import User
+from app.services.auth.user_service import UserService
+
+
+async def get_current_user_from_token(token: str, db: AsyncSession) -> User:
+    """Get current user from JWT token."""
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+
+    # Verify token
+    payload = verify_token(token)
+    if payload is None:
+        raise credentials_exception
+
+    # Get user email from token
+    email = payload.get("sub")
+    if not isinstance(email, str) or email is None:
+        raise credentials_exception
+
+    # Get user from database
+    user_service = UserService(db)
+    user = await user_service.get_user_by_email(email)
+    if user is None:
+        raise credentials_exception
+
+    # Check if user is active
+    if not user.is_active:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED, detail="Inactive user"
+        )
+
+    return user

aegis/templates/cookiecutter-aegis-project/{{cookiecutter.project_slug}}/app/services/auth/health.py

@@ -0,0 +1,164 @@
+"""
+Auth service health check functions.
+
+Health monitoring for authentication and authorization service functionality.
+Checks JWT configuration, database connectivity, and service-specific metrics.
+"""
+
+from app.core.config import settings
+from app.core.log import logger
+from app.services.system.models import ComponentStatus, ComponentStatusType
+
+
+async def check_auth_service_health() -> ComponentStatus:
+    """
+    Check auth service health including JWT configuration and dependencies.
+
+    Returns:
+        ComponentStatus indicating auth service health
+    """
+    try:
+        # Check JWT configuration
+        jwt_errors = []
+
+        # Verify JWT secret key is configured
+        # Note: 32 characters = 256 bits, which is secure for HS256 HMAC-SHA256 signing
+        if not hasattr(settings, "SECRET_KEY") or not settings.SECRET_KEY:
+            jwt_errors.append("SECRET_KEY not configured")
+        elif len(settings.SECRET_KEY) < 32:
+            jwt_errors.append("SECRET_KEY too short (minimum 32 characters for HS256)")
+
+        # Verify JWT algorithm is supported
+        algorithm = getattr(settings, "ALGORITHM", "HS256")
+        supported_algorithms = ["HS256", "HS384", "HS512", "RS256", "RS384", "RS512"]
+        if algorithm not in supported_algorithms:
+            jwt_errors.append(f"Unsupported JWT algorithm: {algorithm}")
+
+        # Verify token expiration is configured
+        access_token_expire = getattr(settings, "ACCESS_TOKEN_EXPIRE_MINUTES", None)
+        if access_token_expire is None or access_token_expire <= 0:
+            jwt_errors.append("ACCESS_TOKEN_EXPIRE_MINUTES not properly configured")
+
+        # Check database dependency for user storage
+        database_available = True
+        try:
+            from sqlalchemy import text
+
+            from app.core.db import db_session
+
+            with db_session() as session:
+                # Test database connectivity with a simple query
+                session.execute(text("SELECT 1"))
+        except ImportError:
+            database_available = False
+            jwt_errors.append("Database module not available for user storage")
+        except Exception as e:
+            database_available = False
+            jwt_errors.append(f"Database connectivity issue: {str(e)}")
+
+        # Determine service status
+        if jwt_errors:
+            if not database_available:
+                status = ComponentStatusType.UNHEALTHY
+                message = f"Auth service misconfigured: {'; '.join(jwt_errors)}"
+            else:
+                # Some JWT config issues but database is available
+                status = ComponentStatusType.WARNING
+                message = (
+                    f"Auth service has configuration warnings: {'; '.join(jwt_errors)}"
+                )
+        else:
+            status = ComponentStatusType.HEALTHY
+            message = "Auth service configured and ready"
+
+        # Get user count for display (limited to avoid performance issues)
+        user_count = 0
+        user_count_display = "0"
+        if database_available:
+            try:
+                from sqlmodel import select
+
+                from app.core.db import db_session
+                from app.models.user import User
+
+                with db_session() as session:
+                    # Count up to 101 users to determine if we should show "100+"
+                    statement = select(User).limit(101)
+                    result = session.exec(statement)
+                    users = list(result.all())
+                    user_count = len(users)
+
+                    user_count_display = "100+" if user_count > 100 else str(user_count)
+            except Exception:
+                # If user counting fails, leave as 0
+                pass
+
+        # Format token expiry for display
+        token_expiry_display = "30 min"  # Default
+        if access_token_expire:
+            if access_token_expire >= 60:
+                hours = access_token_expire // 60
+                token_expiry_display = "1 hour" if hours == 1 else f"{hours} hours"
+            else:
+                token_expiry_display = f"{access_token_expire} min"
+
+        # Determine security level based on configuration
+        security_level = "standard"
+        if jwt_errors:
+            security_level = "basic"
+        elif (
+            hasattr(settings, "SECRET_KEY")
+            and settings.SECRET_KEY
+            and len(settings.SECRET_KEY) >= 64
+            and algorithm in ["RS256", "RS384", "RS512"]
+        ):
+            security_level = "high"
+
+        # Collect metadata
+        metadata = {
+            "service_type": "auth",
+            "jwt_algorithm": algorithm,
+            "token_expiry_minutes": access_token_expire,
+            "token_expiry_display": token_expiry_display,
+            "database_available": database_available,
+            "secret_key_configured": hasattr(settings, "SECRET_KEY")
+            and bool(settings.SECRET_KEY),
+            "secret_key_length": len(getattr(settings, "SECRET_KEY", ""))
+            if hasattr(settings, "SECRET_KEY")
+            else 0,
+            "user_count": user_count,
+            "user_count_display": user_count_display,
+            "security_level": security_level,
+        }
+
+        # Add configuration issues to metadata if any
+        if jwt_errors:
+            metadata["configuration_issues"] = jwt_errors
+
+        # Add dependency status
+        metadata["dependencies"] = {
+            "database": "available" if database_available else "unavailable",
+            "backend": "required",  # Auth service always requires backend
+        }
+
+        return ComponentStatus(
+            name="auth",
+            status=status,
+            message=message,
+            response_time_ms=None,  # Will be set by caller
+            metadata=metadata,
+        )
+
+    except Exception as e:
+        logger.error(f"Auth service health check failed: {e}")
+        return ComponentStatus(
+            name="auth",
+            status=ComponentStatusType.UNHEALTHY,
+            message=f"Auth service health check failed: {str(e)}",
+            response_time_ms=None,
+            metadata={
+                "service_type": "auth",
+                "error": str(e),
+                "error_type": "health_check_failure",
+            },
+        )

aegis/templates/cookiecutter-aegis-project/{{cookiecutter.project_slug}}/app/services/auth/user_service.py

@@ -0,0 +1,83 @@
+"""User management service."""
+
+from datetime import UTC, datetime
+
+from sqlmodel import select
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+from app.core.security import get_password_hash
+from app.models.user import User, UserCreate
+
+
+class UserService:
+    """Service for managing users with async database operations."""
+
+    def __init__(self, db: AsyncSession):
+        self.db = db
+
+    async def create_user(self, user_data: UserCreate) -> User:
+        """Create a new user asynchronously."""
+        # Hash the password
+        hashed_password = get_password_hash(user_data.password)
+
+        # Create user object
+        user = User(
+            email=user_data.email,
+            full_name=user_data.full_name,
+            hashed_password=hashed_password,
+            is_active=user_data.is_active,
+            created_at=datetime.now(UTC),
+        )
+
+        # Save to database
+        self.db.add(user)
+        await self.db.commit()
+        await self.db.refresh(user)
+
+        return user
+
+    async def get_user_by_email(self, email: str) -> User | None:
+        """Get user by email address asynchronously."""
+        statement = select(User).where(User.email == email)
+        result = await self.db.exec(statement)
+        return result.first()
+
+    async def get_user_by_id(self, user_id: int) -> User | None:
+        """Get user by ID asynchronously."""
+        return await self.db.get(User, user_id)
+
+    async def update_user(self, user_id: int, **updates) -> User | None:
+        """Update user data asynchronously."""
+        user = await self.get_user_by_id(user_id)
+        if not user:
+            return None
+
+        for field, value in updates.items():
+            if hasattr(user, field):
+                setattr(user, field, value)
+
+        user.updated_at = datetime.now(UTC)
+        self.db.add(user)
+        await self.db.commit()
+        await self.db.refresh(user)
+
+        return user
+
+    async def deactivate_user(self, user_id: int) -> User | None:
+        """Deactivate a user account asynchronously."""
+        return await self.update_user(user_id, is_active=False)
+
+    async def list_users(self) -> list[User]:
+        """List all users in the system asynchronously."""
+        statement = select(User).order_by(User.created_at.desc())
+        result = await self.db.exec(statement)
+        return list(result.all())
+
+    async def find_existing_emails_with_prefix(
+        self, prefix: str, domain: str
+    ) -> list[str]:
+        """Find existing emails that match the pattern prefix{number}@domain async."""
+        pattern = f"{prefix}%@{domain}"
+        statement = select(User.email).where(User.email.like(pattern))
+        result = await self.db.exec(statement)
+        return list(result.all())