appkit-assistant 0.17.3__py3-none-any.whl → 1.0.0__py3-none-any.whl

appkit_assistant/backend/services/file_validation.py

@@ -0,0 +1,138 @@
+"""File validation service for AI processors.
+
+Provides file type, size, and extension validation utilities
+shared across all processors that handle file uploads.
+"""
+
+import logging
+from pathlib import Path
+from typing import Final
+
+logger = logging.getLogger(__name__)
+
+
+class FileValidationService:
+    """Service for validating files before upload to AI APIs."""
+
+    # Max file size (5MB)
+    MAX_FILE_SIZE: Final[int] = 5 * 1024 * 1024
+
+    # Allowed file extensions
+    ALLOWED_EXTENSIONS: Final[set[str]] = {
+        "pdf",
+        "png",
+        "jpg",
+        "jpeg",
+        "xlsx",
+        "csv",
+        "docx",
+        "pptx",
+        "md",
+    }
+
+    # Image extensions (for determining content type)
+    IMAGE_EXTENSIONS: Final[set[str]] = {"png", "jpg", "jpeg", "gif", "webp"}
+
+    # MIME type mapping
+    MEDIA_TYPES: Final[dict[str, str]] = {
+        "pdf": "application/pdf",
+        "png": "image/png",
+        "jpg": "image/jpeg",
+        "jpeg": "image/jpeg",
+        "gif": "image/gif",
+        "webp": "image/webp",
+        "xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        "csv": "text/csv",
+        "docx": (
+            "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+        ),
+        "pptx": (
+            "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+        ),
+        "md": "text/markdown",
+        "txt": "text/plain",
+    }
+
+    def get_file_extension(self, file_path: str) -> str:
+        """Extract file extension from path.
+
+        Args:
+            file_path: Path to the file
+
+        Returns:
+            Lowercase file extension without the dot, or empty string
+        """
+        return file_path.rsplit(".", 1)[-1].lower() if "." in file_path else ""
+
+    def is_image_file(self, file_path: str) -> bool:
+        """Check if file is an image based on extension.
+
+        Args:
+            file_path: Path to the file
+
+        Returns:
+            True if file has an image extension
+        """
+        ext = self.get_file_extension(file_path)
+        return ext in self.IMAGE_EXTENSIONS
+
+    def get_media_type(self, file_path: str) -> str:
+        """Get MIME type for a file based on extension.
+
+        Args:
+            file_path: Path to the file
+
+        Returns:
+            MIME type string, defaults to application/octet-stream
+        """
+        ext = self.get_file_extension(file_path)
+        return self.MEDIA_TYPES.get(ext, "application/octet-stream")
+
+    def validate_file(self, file_path: str) -> tuple[bool, str]:
+        """Validate file for upload.
+
+        Checks:
+        - File exists
+        - Extension is allowed
+        - File size is within limits
+
+        Args:
+            file_path: Path to the file
+
+        Returns:
+            Tuple of (is_valid, error_message)
+        """
+        path = Path(file_path)
+
+        # Check if file exists
+        if not path.exists():
+            return False, f"File not found: {file_path}"
+
+        # Check extension
+        ext = self.get_file_extension(file_path)
+        if ext not in self.ALLOWED_EXTENSIONS:
+            return False, f"Unsupported file type: {ext}"
+
+        # Check file size
+        file_size = path.stat().st_size
+        if file_size > self.MAX_FILE_SIZE:
+            size_mb = file_size / (1024 * 1024)
+            return False, f"File too large: {size_mb:.1f}MB (max 5MB)"
+
+        return True, ""
+
+
+# Singleton instance for convenience
+_file_validation_service: FileValidationService | None = None
+
+
+def get_file_validation_service() -> FileValidationService:
+    """Get or create the file validation service singleton.
+
+    Returns:
+        The FileValidationService instance
+    """
+    global _file_validation_service
+    if _file_validation_service is None:
+        _file_validation_service = FileValidationService()
+    return _file_validation_service

appkit_assistant/backend/{mcp_auth_service.py → services/mcp_auth_service.py}

@@ -20,11 +20,13 @@ from urllib.parse import urlencode, urlparse
 import httpx
 from sqlmodel import Session, select
 
-from appkit_assistant.backend.models import (
+from appkit_assistant.backend.database.models import (
     AssistantMCPUserToken,
-    MCPAuthType,
     MCPServer,
 )
+from appkit_assistant.backend.schemas import (
+    MCPAuthType,
+)
 from appkit_user.authentication.backend.entities import OAuthStateEntity
 
 logger = logging.getLogger(__name__)

appkit_assistant/backend/services/mcp_token_service.py

@@ -0,0 +1,61 @@
+"""MCP Token Service for OAuth token management.
+
+Provides unified token retrieval and validation for MCP servers
+across all AI processors.
+"""
+
+import logging
+
+import reflex as rx
+
+from appkit_assistant.backend.database.models import AssistantMCPUserToken, MCPServer
+from appkit_assistant.backend.services.mcp_auth_service import MCPAuthService
+
+logger = logging.getLogger(__name__)
+
+
+class MCPTokenService:
+    """Service for managing MCP OAuth tokens."""
+
+    def __init__(self, mcp_auth_service: MCPAuthService) -> None:
+        """Initialize the token service.
+
+        Args:
+            mcp_auth_service: The MCP auth service for token operations
+        """
+        self._mcp_auth_service = mcp_auth_service
+
+    async def get_valid_token(
+        self,
+        server: MCPServer,
+        user_id: int,
+    ) -> AssistantMCPUserToken | None:
+        """Get a valid OAuth token for the given server and user.
+
+        Retrieves the stored token and refreshes it if expired
+        (when a refresh token is available).
+
+        Args:
+            server: The MCP server configuration
+            user_id: The user's ID
+
+        Returns:
+            A valid token or None if not available
+        """
+        if server.id is None:
+            logger.debug("Server %s has no ID, cannot retrieve token", server.name)
+            return None
+
+        with rx.session() as session:
+            token = self._mcp_auth_service.get_user_token(session, user_id, server.id)
+
+            if token is None:
+                logger.debug(
+                    "No token found for user %d on server %s", user_id, server.name
+                )
+                return None
+
+            # Check if token is valid or can be refreshed
+            return await self._mcp_auth_service.ensure_valid_token(
+                session, server, token
+            )

appkit_assistant/backend/services/message_converter.py

@@ -0,0 +1,289 @@
+"""Message Converter Protocol and vendor-specific adapters.
+
+Provides a unified interface for converting internal Message objects
+to vendor-specific API formats.
+"""
+
+import logging
+from abc import ABC, abstractmethod
+from typing import Any, Protocol, TypeVar
+
+from appkit_assistant.backend.schemas import Message, MessageType
+from appkit_assistant.backend.system_prompt_cache import get_system_prompt
+
+logger = logging.getLogger(__name__)
+
+# Type variable for converted message format
+T = TypeVar("T")
+
+
+class MessageConverterProtocol(Protocol[T]):
+    """Protocol for message format converters."""
+
+    async def convert(
+        self,
+        messages: list[Message],
+        mcp_prompt: str = "",
+        file_blocks: list[dict[str, Any]] | None = None,
+    ) -> T:
+        """Convert messages to vendor-specific format.
+
+        Args:
+            messages: List of internal Message objects
+            mcp_prompt: Optional MCP tool prompt to inject
+            file_blocks: Optional file content blocks (for Claude)
+
+        Returns:
+            Vendor-specific message format
+        """
+        ...
+
+
+class BaseMessageConverter(ABC):
+    """Base class for message converters with shared utilities."""
+
+    # Common role mapping
+    ROLE_MAP = {
+        MessageType.HUMAN: "user",
+        MessageType.ASSISTANT: "assistant",
+        MessageType.SYSTEM: "system",
+    }
+
+    def _build_mcp_section(self, mcp_prompt: str) -> str:
+        """Build the MCP tool selection prompt section.
+
+        Args:
+            mcp_prompt: The MCP tool prompts
+
+        Returns:
+            Formatted MCP section or empty string
+        """
+        if not mcp_prompt:
+            return ""
+        return (
+            "### Tool-Auswahlrichtlinien (Einbettung externer Beschreibungen)\n"
+            f"{mcp_prompt}"
+        )
+
+    async def _get_system_prompt_with_mcp(self, mcp_prompt: str = "") -> str:
+        """Get the system prompt with MCP section injected.
+
+        Args:
+            mcp_prompt: Optional MCP tool prompt
+
+        Returns:
+            Complete system prompt
+        """
+        system_prompt_template = await get_system_prompt()
+        mcp_section = self._build_mcp_section(mcp_prompt)
+        return system_prompt_template.format(mcp_prompts=mcp_section)
+
+    @abstractmethod
+    async def convert(
+        self,
+        messages: list[Message],
+        mcp_prompt: str = "",
+        file_blocks: list[dict[str, Any]] | None = None,
+    ) -> Any:
+        """Convert messages to vendor-specific format."""
+
+
+class ClaudeMessageConverter(BaseMessageConverter):
+    """Converter for Claude Messages API format."""
+
+    async def convert(
+        self,
+        messages: list[Message],
+        mcp_prompt: str = "",
+        file_blocks: list[dict[str, Any]] | None = None,
+    ) -> tuple[list[dict[str, Any]], str]:
+        """Convert messages to Claude API format.
+
+        Args:
+            messages: List of internal Message objects
+            mcp_prompt: Optional MCP tool prompt
+            file_blocks: Optional file content blocks to attach to last user message
+
+        Returns:
+            Tuple of (claude_messages, system_prompt)
+        """
+        claude_messages = []
+
+        for i, msg in enumerate(messages):
+            if msg.type == MessageType.SYSTEM:
+                continue  # System messages handled separately
+
+            role = "user" if msg.type == MessageType.HUMAN else "assistant"
+
+            # Build content
+            content: list[dict[str, Any]] = []
+
+            # For the last user message, attach files if present
+            is_last_user = role == "user" and i == len(messages) - 1 and file_blocks
+
+            if is_last_user and file_blocks:
+                content.extend(file_blocks)
+
+            # Add text content
+            content.append({"type": "text", "text": msg.text})
+
+            claude_messages.append(
+                {
+                    "role": role,
+                    "content": content if len(content) > 1 else msg.text,
+                }
+            )
+
+        # Build system prompt
+        system_prompt = await self._get_system_prompt_with_mcp(mcp_prompt)
+
+        return claude_messages, system_prompt
+
+
+class OpenAIResponsesConverter(BaseMessageConverter):
+    """Converter for OpenAI Responses API format."""
+
+    def __init__(self, use_system_prompt: bool = True) -> None:
+        """Initialize the converter.
+
+        Args:
+            use_system_prompt: Whether to prepend system prompt
+        """
+        self._use_system_prompt = use_system_prompt
+
+    async def convert(
+        self,
+        messages: list[Message],
+        mcp_prompt: str = "",
+        file_blocks: list[dict[str, Any]] | None = None,  # noqa: ARG002
+    ) -> list[dict[str, Any]]:
+        """Convert messages to OpenAI Responses API format.
+
+        Args:
+            messages: List of internal Message objects
+            mcp_prompt: Optional MCP tool prompt
+            file_blocks: Not used for OpenAI Responses
+
+        Returns:
+            List of formatted messages with content arrays
+        """
+        input_messages = []
+
+        # Add system message as first message
+        if self._use_system_prompt:
+            system_text = await self._get_system_prompt_with_mcp(mcp_prompt)
+            input_messages.append(
+                {
+                    "role": "system",
+                    "content": [{"type": "input_text", "text": system_text}],
+                }
+            )
+
+        # Add conversation messages
+        for msg in messages:
+            if msg.type == MessageType.SYSTEM:
+                continue  # System messages handled above
+
+            role = "user" if msg.type == MessageType.HUMAN else "assistant"
+            content_type = "input_text" if role == "user" else "output_text"
+            input_messages.append(
+                {"role": role, "content": [{"type": content_type, "text": msg.text}]}
+            )
+
+        return input_messages
+
+
+class OpenAIChatConverter(BaseMessageConverter):
+    """Converter for OpenAI Chat Completions API format.
+
+    Note: This format merges consecutive same-role messages and uses
+    simple string content instead of content arrays.
+    """
+
+    async def convert(
+        self,
+        messages: list[Message],
+        mcp_prompt: str = "",  # noqa: ARG002
+        file_blocks: list[dict[str, Any]] | None = None,  # noqa: ARG002
+    ) -> list[dict[str, str]]:
+        """Convert messages to OpenAI Chat Completions format.
+
+        Merges consecutive user/assistant messages with blank line separator.
+
+        Args:
+            messages: List of internal Message objects
+            mcp_prompt: Not used for chat completions
+            file_blocks: Not used for chat completions
+
+        Returns:
+            List of role/content dicts
+        """
+        formatted: list[dict[str, str]] = []
+
+        for msg in messages or []:
+            if msg.type not in self.ROLE_MAP:
+                continue
+
+            role = self.ROLE_MAP[msg.type]
+
+            # Merge consecutive user/assistant messages
+            if formatted and role != "system" and formatted[-1]["role"] == role:
+                formatted[-1]["content"] = formatted[-1]["content"] + "\n\n" + msg.text
+            else:
+                formatted.append({"role": role, "content": msg.text})
+
+        return formatted
+
+
+class GeminiMessageConverter(BaseMessageConverter):
+    """Converter for Gemini GenAI API format.
+
+    Note: Requires google.genai.types for Content/Part objects.
+    """
+
+    async def convert(
+        self,
+        messages: list[Message],
+        mcp_prompt: str = "",
+        file_blocks: list[dict[str, Any]] | None = None,  # noqa: ARG002
+    ) -> tuple[list[Any], str | None]:
+        """Convert messages to Gemini Content objects.
+
+        Args:
+            messages: List of internal Message objects
+            mcp_prompt: Optional MCP tool prompt
+            file_blocks: Not used for Gemini
+
+        Returns:
+            Tuple of (contents list, system_instruction)
+        """
+        # Import here to avoid hard dependency
+        from google.genai import types  # noqa: PLC0415
+
+        contents: list[types.Content] = []
+        system_instruction: str | None = None
+
+        # Build MCP section
+        mcp_section = ""
+        if mcp_prompt:
+            mcp_section = f"\n\n{self._build_mcp_section(mcp_prompt)}"
+
+        # Get system prompt
+        system_prompt_template = await get_system_prompt()
+        if system_prompt_template:
+            system_instruction = system_prompt_template.format(mcp_prompts=mcp_section)
+
+        for msg in messages:
+            if msg.type == MessageType.SYSTEM:
+                # Append to system instruction
+                if system_instruction:
+                    system_instruction += f"\n{msg.text}"
+                else:
+                    system_instruction = msg.text
+            elif msg.type in (MessageType.HUMAN, MessageType.ASSISTANT):
+                role = "user" if msg.type == MessageType.HUMAN else "model"
+                contents.append(
+                    types.Content(role=role, parts=[types.Part(text=msg.text)])
+                )
+
+        return contents, system_instruction

appkit_assistant/backend/services/openai_client_service.py

@@ -0,0 +1,120 @@
+"""OpenAI client service for creating and managing AsyncOpenAI clients."""
+
+import logging
+
+from openai import AsyncOpenAI
+
+from appkit_assistant.configuration import AssistantConfig
+from appkit_commons.registry import service_registry
+
+logger = logging.getLogger(__name__)
+
+
+class OpenAIClientService:
+    """Service for creating AsyncOpenAI clients with proper configuration.
+
+    This service handles the complexity of creating OpenAI clients for both
+    standard OpenAI API and Azure OpenAI endpoints. It reads configuration
+    from the AssistantConfig and provides a consistent interface for client
+    creation throughout the application.
+
+    Usage:
+        # Get service from registry
+        service = service_registry().get(OpenAIClientService)
+
+        # Create a client
+        client = service.create_client()
+        if client:
+            response = await client.files.list()
+
+        # Check if service is available
+        if service.is_available:
+            ...
+    """
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        base_url: str | None = None,
+        is_azure: bool = False,
+    ) -> None:
+        """Initialize the OpenAI client service.
+
+        Args:
+            api_key: API key for OpenAI or Azure OpenAI.
+            base_url: Base URL for the API (optional).
+            is_azure: Whether to use Azure OpenAI client configuration.
+        """
+        self._api_key = api_key
+        self._base_url = base_url
+        self._is_azure = is_azure
+
+    @classmethod
+    def from_config(cls) -> "OpenAIClientService":
+        """Create an OpenAIClientService from the AssistantConfig.
+
+        Returns:
+            Configured OpenAIClientService instance.
+        """
+        config = service_registry().get(AssistantConfig)
+        api_key = (
+            config.openai_api_key.get_secret_value() if config.openai_api_key else None
+        )
+        return cls(
+            api_key=api_key,
+            base_url=config.openai_base_url,
+            is_azure=config.openai_is_azure,
+        )
+
+    @property
+    def is_available(self) -> bool:
+        """Check if the service is properly configured with an API key."""
+        return self._api_key is not None
+
+    def create_client(self) -> AsyncOpenAI | None:
+        """Create an AsyncOpenAI client with the configured settings.
+
+        Returns:
+            Configured AsyncOpenAI client, or None if API key is not available.
+        """
+        if not self._api_key:
+            logger.warning("OpenAI API key not configured")
+            return None
+
+        if self._api_key and self._base_url and self._is_azure:
+            logger.debug("Creating Azure OpenAI client")
+            return AsyncOpenAI(
+                api_key=self._api_key,
+                base_url=f"{self._base_url}/openai/v1",
+                default_query={"api-version": "preview"},
+            )
+        if self._api_key and self._base_url:
+            logger.debug("Creating OpenAI client with custom base URL")
+            return AsyncOpenAI(api_key=self._api_key, base_url=self._base_url)
+        if self._api_key:
+            logger.debug("Creating standard OpenAI client")
+            return AsyncOpenAI(api_key=self._api_key)
+
+        return None
+
+
+def get_openai_client_service() -> OpenAIClientService:
+    """Get or create the OpenAI client service from the registry.
+
+    This function ensures the service is registered and returns it.
+
+    Returns:
+        The configured OpenAIClientService.
+    """
+    registry = service_registry()
+
+    # Check if already registered
+    try:
+        return registry.get(OpenAIClientService)
+    except KeyError:
+        pass
+
+    # Create and register the service
+    service = OpenAIClientService.from_config()
+    registry.register_as(OpenAIClientService, service)
+    return service