appkit-assistant 0.7.8__tar.gz → 0.9.0__tar.gz

{appkit_assistant-0.7.8 → appkit_assistant-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: appkit-assistant
-Version: 0.7.8
+Version: 0.9.0
 Summary: Add your description here
 Project-URL: Homepage, https://github.com/jenreh/appkit
 Project-URL: Documentation, https://github.com/jenreh/appkit/tree/main/docs

{appkit_assistant-0.7.8 → appkit_assistant-0.9.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "appkit-assistant"
-version = "0.7.8"
+version = "0.9.0"
 description = "Add your description here"
 readme = "README.md"
 authors = [{ name = "Jens Rehpöhler" }]

{appkit_assistant-0.7.8 → appkit_assistant-0.9.0}/src/appkit_assistant/backend/models.py

@@ -1,8 +1,9 @@
+from datetime import datetime
 from enum import StrEnum
 
 import reflex as rx
 from pydantic import BaseModel
-from sqlmodel import Field
+from sqlmodel import Column, DateTime, Field
 
 from appkit_commons.database.entities import EncryptedString
 
@@ -92,6 +93,14 @@ class ThreadModel(BaseModel):
     ai_model: str = ""
 
 
+class MCPAuthType(StrEnum):
+    """Enum for MCP server authentication types."""
+
+    NONE = "none"
+    API_KEY = "api_key"
+    OAUTH_DISCOVERY = "oauth_discovery"
+
+
 class MCPServer(rx.Model, table=True):
     """Model for MCP (Model Context Protocol) server configuration."""
 
@@ -103,3 +112,38 @@ class MCPServer(rx.Model, table=True):
     url: str = Field(nullable=False)
     headers: str = Field(nullable=False, sa_type=EncryptedString)
     prompt: str = Field(default="", max_length=2000, nullable=True)
+
+    # Authentication type
+    auth_type: str = Field(default=MCPAuthType.NONE, nullable=False)
+
+    # Optional discovery URL override
+    discovery_url: str | None = Field(default=None, nullable=True)
+
+    # Cached OAuth/Discovery metadata (read-only for user mostly)
+    oauth_issuer: str | None = Field(default=None, nullable=True)
+    oauth_authorize_url: str | None = Field(default=None, nullable=True)
+    oauth_token_url: str | None = Field(default=None, nullable=True)
+    oauth_scopes: str | None = Field(
+        default=None, nullable=True
+    )  # Space separated scopes
+
+    # Timestamp when discovery was last successfully run
+    oauth_discovered_at: datetime | None = Field(
+        default=None, sa_column=Column(DateTime(timezone=True), nullable=True)
+    )
+
+
+class SystemPrompt(rx.Model, table=True):
+    """Model for system prompt versioning and management.
+
+    Each save creates a new immutable version. Supports up to 20,000 characters.
+    """
+
+    __tablename__ = "system_prompt"
+
+    id: int | None = Field(default=None, primary_key=True)
+    name: str = Field(max_length=200, nullable=False)
+    prompt: str = Field(max_length=20000, nullable=False)
+    version: int = Field(nullable=False)
+    user_id: int = Field(nullable=False)
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))

{appkit_assistant-0.7.8 → appkit_assistant-0.9.0}/src/appkit_assistant/backend/processors/openai_responses_processor.py

@@ -12,7 +12,7 @@ from appkit_assistant.backend.models import (
     MessageType,
 )
 from appkit_assistant.backend.processors.openai_base import BaseOpenAIProcessor
-from appkit_assistant.backend.system_prompt import SYSTEM_PROMPT
+from appkit_assistant.backend.system_prompt_cache import get_system_prompt
 
 logger = logging.getLogger(__name__)
 
@@ -404,7 +404,7 @@ class OpenAIResponsesProcessor(BaseOpenAIProcessor):
         )
 
         # Convert messages to responses format with system message
-        input_messages = self._convert_messages_to_responses_format(
+        input_messages = await self._convert_messages_to_responses_format(
             messages, mcp_prompt=mcp_prompt
         )
 
@@ -453,7 +453,7 @@ class OpenAIResponsesProcessor(BaseOpenAIProcessor):
         prompt_string = "\n".join(prompts) if prompts else ""
         return tools, prompt_string
 
-    def _convert_messages_to_responses_format(
+    async def _convert_messages_to_responses_format(
         self, messages: list[Message], mcp_prompt: str = ""
     ) -> list[dict[str, Any]]:
         """Convert messages to the responses API input format.
@@ -471,7 +471,8 @@ class OpenAIResponsesProcessor(BaseOpenAIProcessor):
         else:
             mcp_prompt = ""
 
-        system_text = SYSTEM_PROMPT.format(mcp_prompts=mcp_prompt)
+        system_prompt_template = await get_system_prompt()
+        system_text = system_prompt_template.format(mcp_prompts=mcp_prompt)
         input_messages.append(
             {
                 "role": "system",

{appkit_assistant-0.7.8 → appkit_assistant-0.9.0}/src/appkit_assistant/backend/repositories.py

@@ -1,10 +1,11 @@
 """Repository for MCP server data access operations."""
 
 import logging
+from datetime import UTC, datetime
 
 import reflex as rx
 
-from appkit_assistant.backend.models import MCPServer
+from appkit_assistant.backend.models import MCPServer, SystemPrompt
 
 logger = logging.getLogger(__name__)
 
@@ -94,3 +95,89 @@ class MCPServerRepository:
                 return True
             logger.warning("MCP server with ID %s not found for deletion", server_id)
             return False
+
+
+class SystemPromptRepository:
+    """Repository class for system prompt database operations.
+
+    Implements append-only versioning with full CRUD capabilities.
+    """
+
+    @staticmethod
+    async def get_all() -> list[SystemPrompt]:
+        """Retrieve all system prompt versions ordered by version descending."""
+        async with rx.asession() as session:
+            result = await session.exec(
+                SystemPrompt.select().order_by(SystemPrompt.version.desc())
+            )
+            return result.all()
+
+    @staticmethod
+    async def get_latest() -> SystemPrompt | None:
+        """Retrieve the latest system prompt version."""
+        async with rx.asession() as session:
+            result = await session.exec(
+                SystemPrompt.select().order_by(SystemPrompt.version.desc()).limit(1)
+            )
+            return result.first()
+
+    @staticmethod
+    async def get_by_id(prompt_id: int) -> SystemPrompt | None:
+        """Retrieve a system prompt by ID."""
+        async with rx.asession() as session:
+            result = await session.exec(
+                SystemPrompt.select().where(SystemPrompt.id == prompt_id)
+            )
+            return result.first()
+
+    @staticmethod
+    async def create(prompt: str, user_id: int) -> SystemPrompt:
+        """Neue System Prompt Version anlegen.
+
+        Version ist fortlaufende Ganzzahl, beginnend bei 1.
+        """
+        async with rx.asession() as session:
+            result = await session.exec(
+                SystemPrompt.select().order_by(SystemPrompt.version.desc()).limit(1)
+            )
+            latest = result.first()
+            next_version = (latest.version + 1) if latest else 1
+
+            name = f"Version {next_version}"
+
+            system_prompt = SystemPrompt(
+                name=name,
+                prompt=prompt,
+                version=next_version,
+                user_id=user_id,
+                created_at=datetime.now(UTC),
+            )
+            session.add(system_prompt)
+            await session.commit()
+            await session.refresh(system_prompt)
+
+            logger.info(
+                "Created system prompt version %s for user %s",
+                next_version,
+                user_id,
+            )
+            return system_prompt
+
+    @staticmethod
+    async def delete(prompt_id: int) -> bool:
+        """Delete a system prompt version by ID."""
+        async with rx.asession() as session:
+            result = await session.exec(
+                SystemPrompt.select().where(SystemPrompt.id == prompt_id)
+            )
+            prompt = result.first()
+            if prompt:
+                await session.delete(prompt)
+                await session.commit()
+                logger.info("Deleted system prompt version: %s", prompt.version)
+                return True
+            logger.warning(
+                "System prompt with ID %s not found for deletion",
+                prompt_id,
+            )
+            return False

appkit_assistant-0.9.0/src/appkit_assistant/backend/system_prompt_cache.py

@@ -0,0 +1,161 @@
+import asyncio
+import logging
+from datetime import UTC, datetime, timedelta
+from typing import Final
+
+from appkit_assistant.backend.repositories import SystemPromptRepository
+
+logger = logging.getLogger(__name__)
+
+# Cache TTL in seconds (default: 5 minutes)
+CACHE_TTL_SECONDS: Final[int] = 300
+
+
+class SystemPromptCache:
+    """Singleton cache for system prompt with TTL-based invalidation.
+
+    Features:
+    - Lazy loading on first access
+    - Automatic cache invalidation after TTL expires
+    - Thread-safe with asyncio lock
+    - Manual invalidation support for immediate updates
+    """
+
+    _instance: "SystemPromptCache | None" = None
+    _lock: asyncio.Lock = asyncio.Lock()
+
+    def __new__(cls) -> "SystemPromptCache":
+        """Ensure singleton pattern."""
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._initialized = False  # noqa: SLF001
+        return cls._instance
+
+    def __init__(self) -> None:
+        """Initialize cache state (only once due to singleton)."""
+        if self._initialized:
+            return
+
+        self._cached_prompt: str | None = None
+        self._cached_version: int | None = None
+        self._cache_timestamp: datetime | None = None
+        self._ttl_seconds: int = CACHE_TTL_SECONDS
+        self._initialized = True
+
+        logger.info(
+            "SystemPromptCache initialized with TTL=%d seconds",
+            self._ttl_seconds,
+        )
+
+    def _is_cache_valid(self) -> bool:
+        """Check if cached prompt is still valid based on TTL."""
+        if self._cached_prompt is None or self._cache_timestamp is None:
+            return False
+
+        elapsed = datetime.now(UTC) - self._cache_timestamp
+        is_valid = elapsed < timedelta(seconds=self._ttl_seconds)
+
+        if not is_valid:
+            logger.debug("Cache expired after %s seconds", elapsed.total_seconds())
+
+        return is_valid
+
+    async def get_prompt(self) -> str:
+        """Get the latest system prompt (from cache or database).
+
+        Returns:
+            The current system prompt text.
+
+        Raises:
+            ValueError: If no system prompt exists in database.
+        """
+        async with self._lock:
+            if self._is_cache_valid():
+                logger.debug(
+                    "Cache hit: version=%d, age=%s seconds",
+                    self._cached_version,
+                    (datetime.now(UTC) - self._cache_timestamp).total_seconds(),
+                )
+                return self._cached_prompt
+
+            # Cache miss or expired - fetch from database
+            logger.info("Cache miss - fetching latest prompt from database")
+
+            latest_prompt = await SystemPromptRepository.get_latest()
+
+            if latest_prompt is None:
+                msg = "No system prompt found in database"
+                logger.error(msg)
+                raise ValueError(msg)
+
+            self._cached_prompt = latest_prompt.prompt
+            self._cached_version = latest_prompt.version
+            self._cache_timestamp = datetime.now(UTC)
+
+            logger.info(
+                "Cached prompt version %d (%d characters)",
+                self._cached_version,
+                len(self._cached_prompt),
+            )
+
+            return self._cached_prompt
+
+    async def invalidate(self) -> None:
+        """Manually invalidate the cache.
+
+        Use this when a new prompt version is created to force
+        immediate reload on next access.
+        """
+        async with self._lock:
+            if self._cached_prompt is not None:
+                logger.info(
+                    "Cache invalidated (was version %d)",
+                    self._cached_version,
+                )
+                self._cached_prompt = None
+                self._cached_version = None
+                self._cache_timestamp = None
+            else:
+                logger.debug("Cache invalidation called but cache was empty")
+
+    def set_ttl(self, seconds: int) -> None:
+        """Update cache TTL.
+
+        Args:
+            seconds: New TTL in seconds.
+        """
+        self._ttl_seconds = seconds
+        logger.info("Cache TTL updated to %d seconds", seconds)
+
+    @property
+    def is_cached(self) -> bool:
+        """Check if prompt is currently cached and valid."""
+        return self._is_cache_valid()
+
+    @property
+    def cached_version(self) -> int | None:
+        """Get the currently cached prompt version (if any)."""
+        return self._cached_version if self._is_cache_valid() else None
+
+
+# Global cache instance
+_prompt_cache = SystemPromptCache()
+
+
+async def get_system_prompt() -> str:
+    """Convenience function to get the current system prompt.
+
+    Returns:
+        The current system prompt text.
+    """
+    return await _prompt_cache.get_prompt()
+
+
+async def invalidate_prompt_cache() -> None:
+    """Convenience function to invalidate the prompt cache."""
+    await _prompt_cache.invalidate()
+
+
+def get_cache_instance() -> SystemPromptCache:
+    """Get the global cache instance for advanced usage."""
+    return _prompt_cache

appkit_assistant-0.9.0/src/appkit_assistant/components/system_prompt_editor.py

@@ -0,0 +1,78 @@
+import reflex as rx
+
+import appkit_mantine as mn
+from appkit_assistant.state.system_prompt_state import SystemPromptState
+from appkit_ui.components.dialogs import delete_dialog
+
+
+def system_prompt_editor() -> rx.Component:
+    """Admin-UI für das System Prompt Versioning mit appkit-mantine & appkit-ui.
+
+    Uses a hybrid approach for the textarea:
+    - default_value + on_change prevents cursor jumping during typing
+    - key prop forces re-render when selecting a different version
+    - This gives us both smooth editing AND the ability to update from select
+    """
+    return rx.vstack(
+        mn.markdown_preview(
+            source=(
+                """
+Der System-Prompt legt fest, wie sich der Assistent verhält. Bitte stellen Sie sicher,
+dass der Platzhalter `{mcp_prompts}` immer im Text enthalten ist. Dieser Platzhalter ist
+notwendig, damit das System im Hintergrund die benötigten Funktionen und Werkzeuge
+automatisch einfügen kann."""
+            ),
+            width="100%",
+        ),
+        mn.textarea(
+            placeholder="System-Prompt hier eingeben (max. 10.000 Zeichen)...",
+            description=f"{SystemPromptState.char_count} / 10.000 Zeichen",
+            default_value=SystemPromptState.current_prompt,
+            on_change=SystemPromptState.set_current_prompt,
+            error=SystemPromptState.error_message,
+            rows=21,
+            variant="filled",
+            width="100%",
+            key=SystemPromptState.textarea_key,
+        ),
+        rx.hstack(
+            mn.select(
+                placeholder="Aktuell",
+                data=SystemPromptState.versions,
+                value=SystemPromptState.selected_version_str,
+                on_change=SystemPromptState.set_selected_version,
+                clearable=False,
+                searchable=False,
+                width="280px",
+            ),
+            delete_dialog(
+                title="Version endgültig löschen?",
+                content="die ausgewählte Version",
+                on_click=SystemPromptState.delete_version,
+                icon_button=True,
+                class_name="dialog",
+                variant="outline",
+                color_scheme="red",
+                disabled=SystemPromptState.is_loading
+                | (SystemPromptState.selected_version_id == 0),
+            ),
+            rx.spacer(),
+            rx.button(
+                "Neue Version speichern",
+                on_click=SystemPromptState.save_current,
+                disabled=SystemPromptState.is_loading
+                | (
+                    SystemPromptState.current_prompt
+                    == SystemPromptState.last_saved_prompt
+                ),
+                loading=SystemPromptState.is_loading,
+            ),
+            align="center",
+            width="100%",
+            spacing="4",
+        ),
+        width="100%",
+        max_width="960px",
+        padding="6",
+        spacing="5",
+    )

appkit_assistant-0.9.0/src/appkit_assistant/state/system_prompt_state.py

@@ -0,0 +1,181 @@
+import logging
+from collections.abc import AsyncGenerator
+from typing import Any, Final
+
+import reflex as rx
+from reflex.state import State
+
+from appkit_assistant.backend.repositories import SystemPromptRepository
+from appkit_assistant.backend.system_prompt_cache import invalidate_prompt_cache
+from appkit_user.authentication.states import UserSession
+
+logger = logging.getLogger(__name__)
+
+MAX_PROMPT_LENGTH: Final[int] = 10000
+
+
+class SystemPromptState(State):
+    """State für System Prompt Editing und Versionierung."""
+
+    current_prompt: str = ""
+    last_saved_prompt: str = ""
+    versions: list[dict[str, str | int]] = []
+    prompt_map: dict[str, str] = {}
+    selected_version_id: int = 0
+    is_loading: bool = False
+    error_message: str = ""
+    char_count: int = 0
+    # Trigger to force textarea update when selecting a version
+    textarea_key: int = 0
+
+    async def load_versions(self) -> None:
+        """Alle System Prompt Versionen laden."""
+        self.is_loading = True
+        self.error_message = ""
+        try:
+            prompts = await SystemPromptRepository.get_all()
+            self.versions = [
+                {
+                    "value": str(p.version),
+                    "label": (
+                        f"Version {p.version} - "
+                        f"{p.created_at.strftime('%d.%m.%Y %H:%M')}"
+                    ),
+                }
+                for p in prompts
+            ]
+
+            # Populate map for fast switching
+            self.prompt_map = {str(p.version): p.prompt for p in prompts}
+
+            if prompts:
+                latest = prompts[0]
+                # Automatically select the latest version
+                self.selected_version_id = latest.version
+
+                if not self.current_prompt:
+                    self.current_prompt = latest.prompt
+                    self.last_saved_prompt = latest.prompt
+                else:
+                    self.last_saved_prompt = latest.prompt
+            else:
+                self.selected_version_id = 0
+                if not self.current_prompt:
+                    self.current_prompt = ""
+                self.last_saved_prompt = self.current_prompt
+
+            # Zähler initial setzen
+            self.char_count = len(self.current_prompt)
+
+            logger.info("Loaded %s system prompt versions", len(self.versions))
+        except Exception as exc:
+            self.error_message = f"Fehler beim Laden: {exc!s}"
+            logger.exception("Failed to load system prompt versions")
+        finally:
+            self.is_loading = False
+
+    async def save_current(self) -> AsyncGenerator[Any, Any]:
+        if self.current_prompt == self.last_saved_prompt:
+            yield rx.toast.info("Es wurden keine Änderungen erkannt.")
+            return
+
+        if not self.current_prompt.strip():
+            self.error_message = "Prompt darf nicht leer sein."
+            yield rx.toast.error("Prompt darf nicht leer sein.")
+            return
+
+        if len(self.current_prompt) > MAX_PROMPT_LENGTH:
+            self.error_message = "Prompt darf maximal 20.000 Zeichen enthalten."
+            yield rx.toast.error("Prompt ist zu lang (max. 20.000 Zeichen).")
+            return
+
+        self.is_loading = True
+        self.error_message = ""
+        try:
+            user_session: UserSession = await self.get_state(UserSession)
+            user_id = user_session.user_id
+
+            await SystemPromptRepository.create(
+                prompt=self.current_prompt,
+                user_id=user_id,
+            )
+
+            self.last_saved_prompt = self.current_prompt
+
+            # Invalidate cache to force reload of new prompt version
+            await invalidate_prompt_cache()
+            logger.info("System prompt cache invalidated after save")
+
+            await self.load_versions()
+
+            yield rx.toast.success("Neue Version erfolgreich gespeichert.")
+            logger.info("Saved new system prompt version by user %s", user_id)
+        except Exception as exc:
+            self.error_message = f"Fehler beim Speichern: {exc!s}"
+            logger.exception("Failed to save system prompt")
+            yield rx.toast.error(f"Fehler: {exc!s}")
+        finally:
+            self.is_loading = False
+
+    async def delete_version(self) -> AsyncGenerator[Any, Any]:
+        if not self.selected_version_id:
+            self.error_message = "Keine Version ausgewählt."
+            yield rx.toast.error("Bitte zuerst eine Version auswählen.")
+            return
+
+        self.is_loading = True
+        self.error_message = ""
+        try:
+            success = await SystemPromptRepository.delete(self.selected_version_id)
+            if success:
+                self.selected_version_id = 0
+
+                # Invalidate cache since latest version might have changed
+                await invalidate_prompt_cache()
+                logger.info("System prompt cache invalidated after deletion")
+
+                await self.load_versions()
+                yield rx.toast.success("Version erfolgreich gelöscht.")
+            else:
+                self.error_message = "Version nicht gefunden."
+                yield rx.toast.error("Version nicht gefunden.")
+        except Exception as exc:
+            self.error_message = f"Fehler beim Löschen: {exc!s}"
+            logger.exception("Failed to delete version")
+            yield rx.toast.error(f"Fehler: {exc!s}")
+        finally:
+            self.is_loading = False
+
+    def set_current_prompt(self, value: str) -> None:
+        """Update current prompt text and char count.
+
+        This is called on every keystroke but doesn't cause cursor jumping
+        because we use default_value in the textarea component.
+        """
+        self.current_prompt = value
+        self.char_count = len(value)
+
+    def set_selected_version(self, value: str | None) -> None:
+        """Handle version selection and load corresponding prompt.
+
+        When a version is selected, we update the prompt content and force
+        the textarea to re-render by changing its key.
+        """
+        if value is None or value == "":
+            return
+
+        self.selected_version_id = int(value)
+
+        # Load the prompt for the selected version
+        if value in self.prompt_map:
+            self.current_prompt = self.prompt_map[value]
+            self.char_count = len(self.current_prompt)
+            # Force textarea to re-render with new content
+            self.textarea_key += 1
+
+    @rx.var
+    def selected_version_str(self) -> str:
+        """Return selected version as string for the select component."""
+        if self.selected_version_id == 0:
+            return ""
+        return str(self.selected_version_id)