appkit-assistant 0.8.0__py3-none-any.whl → 0.10.0__py3-none-any.whl

appkit_assistant/backend/models.py

@@ -1,10 +1,34 @@
+import json
+from datetime import UTC, datetime
 from enum import StrEnum
+from typing import Any
 
 import reflex as rx
 from pydantic import BaseModel
-from sqlmodel import Field
+from sqlalchemy.sql import func
+from sqlmodel import Column, DateTime, Field
 
+from appkit_commons.database.configuration import DatabaseConfig
 from appkit_commons.database.entities import EncryptedString
+from appkit_commons.registry import service_registry
+
+db_config = service_registry().get(DatabaseConfig)
+SECRET_VALUE = db_config.encryption_key.get_secret_value()
+
+
+class EncryptedJSON(EncryptedString):
+    """Custom type for storing encrypted JSON data."""
+
+    def process_bind_param(self, value: Any, dialect: Any) -> str | None:
+        if value is not None:
+            value = json.dumps(value)
+        return super().process_bind_param(value, dialect)
+
+    def process_result_value(self, value: Any, dialect: Any) -> Any | None:
+        value = super().process_result_value(value, dialect)
+        if value is not None:
+            return json.loads(value)
+        return value
 
 
 class ChunkType(StrEnum):
@@ -39,6 +63,7 @@ class ThreadStatus(StrEnum):
     ACTIVE = "active"
     IDLE = "idle"
     WAITING = "waiting"
+    ERROR = "error"
     DELETED = "deleted"
     ARCHIVED = "archived"
 
@@ -92,10 +117,18 @@ 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."""
 
-    __tablename__ = "mcp_server"
+    __tablename__ = "assistant_mcp_servers"
 
     id: int | None = Field(default=None, primary_key=True)
     name: str = Field(unique=True, max_length=100, nullable=False)
@@ -103,3 +136,61 @@ 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__ = "assistant_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))
+
+
+class AssistantThread(rx.Model, table=True):
+    """Model for storing chat threads in the database."""
+
+    __tablename__ = "assistant_thread"
+
+    id: int | None = Field(default=None, primary_key=True)
+    thread_id: str = Field(unique=True, index=True, nullable=False)
+    user_id: int = Field(index=True, nullable=False)
+    title: str = Field(default="", nullable=False)
+    state: str = Field(default=ThreadStatus.NEW, nullable=False)
+    ai_model: str = Field(default="", nullable=False)
+    active: bool = Field(default=False, nullable=False)
+    messages: list[dict[str, Any]] = Field(default=[], sa_column=Column(EncryptedJSON))
+    created_at: datetime = Field(
+        default_factory=lambda: datetime.now(UTC),
+        sa_column=Column(DateTime(timezone=True)),
+    )
+    updated_at: datetime = Field(
+        default_factory=lambda: datetime.now(UTC),
+        sa_column=Column(DateTime(timezone=True), onupdate=func.now()),
+    )

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,8 +453,11 @@ class OpenAIResponsesProcessor(BaseOpenAIProcessor):
         prompt_string = "\n".join(prompts) if prompts else ""
         return tools, prompt_string
 
-    def _convert_messages_to_responses_format(
-        self, messages: list[Message], mcp_prompt: str = ""
+    async def _convert_messages_to_responses_format(
+        self,
+        messages: list[Message],
+        mcp_prompt: str = "",
+        use_system_prompt: bool = True,
     ) -> list[dict[str, Any]]:
         """Convert messages to the responses API input format.
 
@@ -471,13 +474,15 @@ class OpenAIResponsesProcessor(BaseOpenAIProcessor):
         else:
             mcp_prompt = ""
 
-        system_text = SYSTEM_PROMPT.format(mcp_prompts=mcp_prompt)
-        input_messages.append(
-            {
-                "role": "system",
-                "content": [{"type": "input_text", "text": system_text}],
-            }
-        )
+        if use_system_prompt:
+            system_prompt_template = await get_system_prompt()
+            system_text = system_prompt_template.format(mcp_prompts=mcp_prompt)
+            input_messages.append(
+                {
+                    "role": "system",
+                    "content": [{"type": "input_text", "text": system_text}],
+                }
+            )
 
         # Add conversation messages
         for msg in messages:

appkit_assistant/backend/repositories.py

@@ -1,10 +1,19 @@
 """Repository for MCP server data access operations."""
 
 import logging
+from datetime import UTC, datetime
 
 import reflex as rx
+from sqlalchemy.orm import defer
 
-from appkit_assistant.backend.models import MCPServer
+from appkit_assistant.backend.models import (
+    AssistantThread,
+    MCPServer,
+    Message,
+    SystemPrompt,
+    ThreadModel,
+    ThreadStatus,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -94,3 +103,221 @@ 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
+
+
+class ThreadRepository:
+    """Repository class for Thread database operations."""
+
+    @staticmethod
+    async def get_by_user(user_id: int) -> list[ThreadModel]:
+        """Retrieve all threads for a user."""
+        async with rx.asession() as session:
+            result = await session.exec(
+                AssistantThread.select()
+                .where(AssistantThread.user_id == user_id)
+                .order_by(AssistantThread.updated_at.desc())
+            )
+            threads = result.all()
+            return [
+                ThreadModel(
+                    thread_id=t.thread_id,
+                    title=t.title,
+                    state=ThreadStatus(t.state),
+                    ai_model=t.ai_model,
+                    active=t.active,
+                    messages=[Message(**m) for m in t.messages],
+                )
+                for t in threads
+            ]
+
+    @staticmethod
+    async def save_thread(thread: ThreadModel, user_id: int) -> None:
+        """Save or update a thread."""
+        async with rx.asession() as session:
+            result = await session.exec(
+                AssistantThread.select().where(
+                    AssistantThread.thread_id == thread.thread_id
+                )
+            )
+            db_thread = result.first()
+
+            messages_dict = [m.dict() for m in thread.messages]
+
+            if db_thread:
+                # Ensure user owns the thread or handle shared threads logic if needed
+                # For now, we assume thread_id is unique enough,
+                # but checking user_id is safer
+                if db_thread.user_id != user_id:
+                    logger.warning(
+                        "User %s tried to update thread %s belonging to user %s",
+                        user_id,
+                        thread.thread_id,
+                        db_thread.user_id,
+                    )
+                    return
+
+                db_thread.title = thread.title
+                db_thread.state = thread.state.value
+                db_thread.ai_model = thread.ai_model
+                db_thread.active = thread.active
+                db_thread.messages = messages_dict
+                session.add(db_thread)
+            else:
+                db_thread = AssistantThread(
+                    thread_id=thread.thread_id,
+                    user_id=user_id,
+                    title=thread.title,
+                    state=thread.state.value,
+                    ai_model=thread.ai_model,
+                    active=thread.active,
+                    messages=messages_dict,
+                )
+                session.add(db_thread)
+
+            await session.commit()
+
+    @staticmethod
+    async def delete_thread(thread_id: str, user_id: int) -> None:
+        """Delete a thread."""
+        async with rx.asession() as session:
+            result = await session.exec(
+                AssistantThread.select().where(
+                    AssistantThread.thread_id == thread_id,
+                    AssistantThread.user_id == user_id,
+                )
+            )
+            thread = result.first()
+            if thread:
+                await session.delete(thread)
+                await session.commit()
+
+    @staticmethod
+    async def get_summaries_by_user(user_id: int) -> list[ThreadModel]:
+        """Retrieve thread summaries (no messages) for a user."""
+        async with rx.asession() as session:
+            result = await session.exec(
+                AssistantThread.select()
+                .where(AssistantThread.user_id == user_id)
+                .options(defer(AssistantThread.messages))
+                .order_by(AssistantThread.updated_at.desc())
+            )
+            threads = result.all()
+            return [
+                ThreadModel(
+                    thread_id=t.thread_id,
+                    title=t.title,
+                    state=ThreadStatus(t.state),
+                    ai_model=t.ai_model,
+                    active=t.active,
+                    messages=[],  # Empty messages for summary
+                )
+                for t in threads
+            ]
+
+    @staticmethod
+    async def get_thread_by_id(thread_id: str, user_id: int) -> ThreadModel | None:
+        """Retrieve a full thread by ID."""
+        async with rx.asession() as session:
+            result = await session.exec(
+                AssistantThread.select().where(
+                    AssistantThread.thread_id == thread_id,
+                    AssistantThread.user_id == user_id,
+                )
+            )
+            t = result.first()
+            if not t:
+                return None
+            return ThreadModel(
+                thread_id=t.thread_id,
+                title=t.title,
+                state=ThreadStatus(t.state),
+                ai_model=t.ai_model,
+                active=t.active,
+                messages=[Message(**m) for m in t.messages],
+            )

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/components/__init__.py

@@ -12,10 +12,8 @@ from appkit_assistant.backend.models import (
     ThreadModel,
     ThreadStatus,
 )
-from appkit_assistant.state.thread_state import (
-    ThreadState,
-    ThreadListState,
-)
+from appkit_assistant.state.thread_list_state import ThreadListState
+from appkit_assistant.state.thread_state import ThreadState
 from appkit_assistant.components.mcp_server_table import mcp_servers_table
 
 __all__ = [

appkit_assistant/components/mcp_server_dialogs.py

@@ -258,10 +258,15 @@ def add_mcp_server_button() -> rx.Component:
         rx.dialog.trigger(
             rx.button(
                 rx.icon("plus"),
-                rx.text("Neuen MCP Server anlegen", display=["none", "none", "block"]),
-                size="3",
+                rx.text(
+                    "Neuen MCP Server anlegen",
+                    display=["none", "none", "block"],
+                    size="2",
+                ),
+                size="2",
                 variant="solid",
                 on_click=[ValidationState.initialize(server=None)],
+                margin_bottom="15px",
             ),
         ),
         rx.dialog.content(

appkit_assistant/components/message.py

@@ -54,7 +54,7 @@ class MessageComponent:
 
         # Show thinking content only for the last assistant message
         should_show_thinking = (
-            message.text == ThreadState.last_assistant_message_text
+            message.text == ThreadState.get_last_assistant_message_text
         ) & ThreadState.has_thinking_content
 
         # Main content area with all components
@@ -74,9 +74,9 @@ class MessageComponent:
                 ),
                 title="Denkprozess & Werkzeuge",
                 info_text=(
-                    f"{ThreadState.unique_reasoning_sessions.length()} "
+                    f"{ThreadState.get_unique_reasoning_sessions.length()} "
                     f"Nachdenken, "
-                    f"{ThreadState.unique_tool_calls.length()} Werkzeuge"
+                    f"{ThreadState.get_unique_tool_calls.length()} Werkzeuge"
                 ),
                 show_condition=should_show_thinking,
                 expanded=ThreadState.thinking_expanded,