appkit-assistant 0.13.0__py3-none-any.whl → 0.14.0__py3-none-any.whl

appkit_assistant/backend/repositories.py

@@ -3,321 +3,160 @@
 import logging
 from datetime import UTC, datetime
 
-import reflex as rx
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import defer
 
 from appkit_assistant.backend.models import (
     AssistantThread,
     MCPServer,
-    Message,
     SystemPrompt,
-    ThreadModel,
-    ThreadStatus,
 )
+from appkit_commons.database.base_repository import BaseRepository
 
 logger = logging.getLogger(__name__)
 
 
-class MCPServerRepository:
+class MCPServerRepository(BaseRepository[MCPServer, AsyncSession]):
     """Repository class for MCP server database operations."""
 
-    @staticmethod
-    async def get_all() -> list[MCPServer]:
-        """Retrieve all MCP servers ordered by name."""
-        async with rx.asession() as session:
-            result = await session.exec(MCPServer.select().order_by(MCPServer.name))
-            return result.all()
-
-    @staticmethod
-    async def get_by_id(server_id: int) -> MCPServer | None:
-        """Retrieve an MCP server by ID."""
-        async with rx.asession() as session:
-            result = await session.exec(
-                MCPServer.select().where(MCPServer.id == server_id)
-            )
-            return result.first()
-
-    @staticmethod
-    async def create(
-        name: str,
-        url: str,
-        headers: str,
-        description: str | None = None,
-        prompt: str | None = None,
-    ) -> MCPServer:
-        """Create a new MCP server."""
-        async with rx.asession() as session:
-            server = MCPServer(
-                name=name,
-                url=url,
-                headers=headers,
-                description=description,
-                prompt=prompt,
-            )
-            session.add(server)
-            await session.commit()
-            await session.refresh(server)
-            logger.debug("Created MCP server: %s", name)
-            return server
+    @property
+    def model_class(self) -> type[MCPServer]:
+        return MCPServer
 
-    @staticmethod
-    async def update(
-        server_id: int,
-        name: str,
-        url: str,
-        headers: str,
-        description: str | None = None,
-        prompt: str | None = None,
-    ) -> MCPServer | None:
-        """Update an existing MCP server."""
-        async with rx.asession() as session:
-            result = await session.exec(
-                MCPServer.select().where(MCPServer.id == server_id)
-            )
-            server = result.first()
-            if server:
-                server.name = name
-                server.url = url
-                server.headers = headers
-                server.description = description
-                server.prompt = prompt
-                await session.commit()
-                await session.refresh(server)
-                logger.debug("Updated MCP server: %s", name)
-                return server
-            logger.warning("MCP server with ID %s not found for update", server_id)
-            return None
-
-    @staticmethod
-    async def delete(server_id: int) -> bool:
-        """Delete an MCP server by ID."""
-        async with rx.asession() as session:
-            result = await session.exec(
-                MCPServer.select().where(MCPServer.id == server_id)
-            )
-            server = result.first()
-            if server:
-                await session.delete(server)
-                await session.commit()
-                logger.debug("Deleted MCP server: %s", server.name)
-                return True
-            logger.warning("MCP server with ID %s not found for deletion", server_id)
-            return False
+    async def find_all_ordered_by_name(self, session: AsyncSession) -> list[MCPServer]:
+        """Retrieve all MCP servers ordered by name."""
+        stmt = select(MCPServer).order_by(MCPServer.name)
+        result = await session.execute(stmt)
+        return list(result.scalars().all())
 
 
-class SystemPromptRepository:
+class SystemPromptRepository(BaseRepository[SystemPrompt, AsyncSession]):
     """Repository class for system prompt database operations.
 
     Implements append-only versioning with full CRUD capabilities.
     """
 
-    @staticmethod
-    async def get_all() -> list[SystemPrompt]:
+    @property
+    def model_class(self) -> type[SystemPrompt]:
+        return SystemPrompt
+
+    async def find_all_ordered_by_version_desc(
+        self, session: AsyncSession
+    ) -> 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()
+        stmt = select(SystemPrompt).order_by(SystemPrompt.version.desc())
+        result = await session.execute(stmt)
+        return list(result.scalars().all())
 
-    @staticmethod
-    async def get_latest() -> SystemPrompt | None:
+    async def find_latest(self, session: AsyncSession) -> 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()
+        stmt = select(SystemPrompt).order_by(SystemPrompt.version.desc()).limit(1)
+        result = await session.execute(stmt)
+        return result.scalars().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:
+    async def create_next_version(
+        self, session: AsyncSession, 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:
+        stmt = select(SystemPrompt).order_by(SystemPrompt.version.desc()).limit(1)
+        result = await session.execute(stmt)
+        latest = result.scalars().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.flush()
+        await session.refresh(system_prompt)
+
+        logger.info(
+            "Created system prompt version %s for user %s",
+            next_version,
+            user_id,
+        )
+        return system_prompt
+
+
+class ThreadRepository(BaseRepository[AssistantThread, AsyncSession]):
     """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
+    @property
+    def model_class(self) -> type[AssistantThread]:
+        return AssistantThread
 
-                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]:
+    async def find_by_user(
+        self, session: AsyncSession, user_id: int
+    ) -> list[AssistantThread]:
+        """Retrieve all threads for a user."""
+        stmt = (
+            select(AssistantThread)
+            .where(AssistantThread.user_id == user_id)
+            .order_by(AssistantThread.updated_at.desc())
+        )
+        result = await session.execute(stmt)
+        return list(result.scalars().all())
+
+    async def find_by_thread_id(
+        self, session: AsyncSession, thread_id: str
+    ) -> AssistantThread | None:
+        """Retrieve a thread by its thread_id."""
+        stmt = select(AssistantThread).where(AssistantThread.thread_id == thread_id)
+        result = await session.execute(stmt)
+        return result.scalars().first()
+
+    async def find_by_thread_id_and_user(
+        self, session: AsyncSession, thread_id: str, user_id: int
+    ) -> AssistantThread | None:
+        """Retrieve a thread by thread_id and user_id."""
+        stmt = select(AssistantThread).where(
+            AssistantThread.thread_id == thread_id,
+            AssistantThread.user_id == user_id,
+        )
+        result = await session.execute(stmt)
+        return result.scalars().first()
+
+    async def delete_by_thread_id_and_user(
+        self, session: AsyncSession, thread_id: str, user_id: int
+    ) -> bool:
+        """Delete a thread by thread_id and user_id."""
+        stmt = select(AssistantThread).where(
+            AssistantThread.thread_id == thread_id,
+            AssistantThread.user_id == user_id,
+        )
+        result = await session.execute(stmt)
+        thread = result.scalars().first()
+        if thread:
+            await session.delete(thread)
+            await session.flush()
+            return True
+        return False
+
+    async def find_summaries_by_user(
+        self, session: AsyncSession, user_id: int
+    ) -> list[AssistantThread]:
         """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],
-            )
+        stmt = (
+            select(AssistantThread)
+            .where(AssistantThread.user_id == user_id)
+            .options(defer(AssistantThread.messages))
+            .order_by(AssistantThread.updated_at.desc())
+        )
+        result = await session.execute(stmt)
+        return list(result.scalars().all())
+
+
+# Export instances
+mcp_server_repo = MCPServerRepository()
+system_prompt_repo = SystemPromptRepository()
+thread_repo = ThreadRepository()

appkit_assistant/backend/system_prompt_cache.py

@@ -3,7 +3,8 @@ import logging
 from datetime import UTC, datetime, timedelta
 from typing import Final
 
-from appkit_assistant.backend.repositories import SystemPromptRepository
+from appkit_assistant.backend.repositories import system_prompt_repo
+from appkit_commons.database.session import get_asyncdb_session
 
 logger = logging.getLogger(__name__)
 
@@ -81,15 +82,24 @@ class SystemPromptCache:
             # Cache miss or expired - fetch from database
             logger.info("Cache miss - fetching latest prompt from database")
 
-            latest_prompt = await SystemPromptRepository.get_latest()
+            async with get_asyncdb_session() as session:
+                latest_prompt = await system_prompt_repo.find_latest(session)
+
+                if latest_prompt is None:
+                    # Raise inside to exit or handle outside
+                    pass
+                else:
+                    # Capture values while attached
+                    prompt_text = latest_prompt.prompt
+                    prompt_version = latest_prompt.version
 
             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._cached_prompt = prompt_text
+            self._cached_version = prompt_version
             self._cache_timestamp = datetime.now(UTC)
 
             logger.info(

appkit_assistant/components/mcp_server_dialogs.py

@@ -130,7 +130,7 @@ class ValidationState(rx.State):
 @var_operation
 def json(obj: rx.Var, indent: int = 4) -> CustomVarOperationReturn[RETURN]:
     return var_operation_return(
-        js_expression=f"JSON.stringify(JSON.parse({obj}), null, {indent})",
+        js_expression=f"JSON.stringify(JSON.parse({obj} || '{{}}'), null, {indent})",
         var_type=Any,
     )
 

appkit_assistant/state/mcp_server_state.py

@@ -9,8 +9,9 @@ import reflex as rx
 
 from appkit_assistant.backend.models import MCPServer
 from appkit_assistant.backend.repositories import (
-    MCPServerRepository,
+    mcp_server_repo,
 )
+from appkit_commons.database.session import get_asyncdb_session
 
 logger = logging.getLogger(__name__)
 
@@ -29,7 +30,9 @@ class MCPServerState(rx.State):
         """
         self.loading = True
         try:
-            self.servers = await MCPServerRepository.get_all()
+            async with get_asyncdb_session() as session:
+                servers = await mcp_server_repo.find_all_ordered_by_name(session)
+                self.servers = [MCPServer(**s.model_dump()) for s in servers]
             logger.debug("Loaded %d MCP servers", len(self.servers))
         except Exception as e:
             logger.error("Failed to load MCP servers: %s", e)
@@ -50,7 +53,13 @@ class MCPServerState(rx.State):
     async def get_server(self, server_id: int) -> None:
         """Get a specific MCP server by ID."""
         try:
-            self.current_server = await MCPServerRepository.get_by_id(server_id)
+            async with get_asyncdb_session() as session:
+                server = await mcp_server_repo.find_by_id(session, server_id)
+                if server:
+                    self.current_server = MCPServer(**server.model_dump())
+                else:
+                    self.current_server = None
+
             if not self.current_server:
                 logger.warning("MCP server with ID %d not found", server_id)
         except Exception as e:
@@ -64,7 +73,7 @@ class MCPServerState(rx.State):
         """Add a new MCP server."""
         try:
             headers = self._parse_headers_from_form(form_data)
-            server = await MCPServerRepository.create(
+            server_entity = MCPServer(
                 name=form_data["name"],
                 url=form_data["url"],
                 headers=headers,
@@ -72,12 +81,17 @@ class MCPServerState(rx.State):
                 prompt=form_data.get("prompt") or None,
             )
 
+            async with get_asyncdb_session() as session:
+                server = await mcp_server_repo.save(session, server_entity)
+                # Ensure we have the name before session closes if used later
+                server_name = server.name
+
             await self.load_servers()
             yield rx.toast.info(
                 "MCP Server {} wurde hinzugefügt.".format(form_data["name"]),
                 position="top-right",
             )
-            logger.debug("Added MCP server: %s", server.name)
+            logger.debug("Added MCP server: %s", server_name)
 
         except ValueError as e:
             logger.error("Invalid form data for MCP server: %s", e)
@@ -105,22 +119,34 @@ class MCPServerState(rx.State):
 
         try:
             headers = self._parse_headers_from_form(form_data)
-            updated_server = await MCPServerRepository.update(
-                server_id=self.current_server.id,
-                name=form_data["name"],
-                url=form_data["url"],
-                headers=headers,
-                description=form_data.get("description") or None,
-                prompt=form_data.get("prompt") or None,
-            )
+            updated_name = ""
 
-            if updated_server:
+            async with get_asyncdb_session() as session:
+                # Re-fetch server to ensure we have the latest and bound to session
+                existing_server = await mcp_server_repo.find_by_id(
+                    session, self.current_server.id
+                )
+
+                updated_server = None
+                if existing_server:
+                    existing_server.name = form_data["name"]
+                    existing_server.url = form_data["url"]
+                    existing_server.headers = headers
+                    existing_server.description = form_data.get("description") or None
+                    existing_server.prompt = form_data.get("prompt") or None
+
+                    updated_server = await mcp_server_repo.save(
+                        session, existing_server
+                    )
+                    updated_name = updated_server.name
+
+            if updated_name:
                 await self.load_servers()
                 yield rx.toast.info(
                     "MCP Server {} wurde aktualisiert.".format(form_data["name"]),
                     position="top-right",
                 )
-                logger.debug("Updated MCP server: %s", updated_server.name)
+                logger.debug("Updated MCP server: %s", updated_name)
             else:
                 yield rx.toast.error(
                     "MCP Server konnte nicht gefunden werden.",
@@ -143,19 +169,20 @@ class MCPServerState(rx.State):
     async def delete_server(self, server_id: int) -> AsyncGenerator[Any, Any]:
         """Delete an MCP server."""
         try:
-            # Get server name for the success message
-            server = await MCPServerRepository.get_by_id(server_id)
-            if not server:
-                yield rx.toast.error(
-                    "MCP Server nicht gefunden.",
-                    position="top-right",
-                )
-                return
-
-            server_name = server.name
-
-            # Delete server using repository
-            success = await MCPServerRepository.delete(server_id)
+            async with get_asyncdb_session() as session:
+                # Get server name for the success message
+                server = await mcp_server_repo.find_by_id(session, server_id)
+                if not server:
+                    yield rx.toast.error(
+                        "MCP Server nicht gefunden.",
+                        position="top-right",
+                    )
+                    return
+
+                server_name = server.name
+
+                # Delete server using repository
+                success = await mcp_server_repo.delete_by_id(session, server_id)
 
             if success:
                 await self.load_servers()

appkit_assistant/state/system_prompt_state.py

@@ -5,8 +5,9 @@ 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.repositories import system_prompt_repo
 from appkit_assistant.backend.system_prompt_cache import invalidate_prompt_cache
+from appkit_commons.database.session import get_asyncdb_session
 from appkit_user.authentication.states import UserSession
 
 logger = logging.getLogger(__name__)
@@ -32,31 +33,41 @@ class SystemPromptState(State):
         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
-            ]
-
-            self.prompt_map = {str(p.version): p.prompt for p in prompts}
-
-            if prompts:
-                latest = prompts[0]
-                self.selected_version_id = latest.version
+            async with get_asyncdb_session() as session:
+                prompts = await system_prompt_repo.find_all_ordered_by_version_desc(
+                    session
+                )
+
+                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
+                ]
+
+                self.prompt_map = {str(p.version): p.prompt for p in prompts}
+
+                latest_prompt = None
+                if prompts:
+                    latest_prompt = prompts[0]
+                    # Access attributes to ensure they are loaded/available
+                    self.selected_version_id = latest_prompt.version
+                    latest_prompt_text = latest_prompt.prompt
+                else:
+                    self.selected_version_id = 0
+                    latest_prompt_text = None
 
+            if latest_prompt_text is not None:
                 if not self.current_prompt:
-                    self.current_prompt = latest.prompt
-                    self.last_saved_prompt = latest.prompt
+                    self.current_prompt = latest_prompt_text
+                    self.last_saved_prompt = latest_prompt_text
                 else:
-                    self.last_saved_prompt = latest.prompt
+                    self.last_saved_prompt = latest_prompt_text
             else:
-                self.selected_version_id = 0
                 if not self.current_prompt:
                     self.current_prompt = ""
                 self.last_saved_prompt = self.current_prompt
@@ -93,10 +104,12 @@ class SystemPromptState(State):
             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,
-            )
+            async with get_asyncdb_session() as session:
+                await system_prompt_repo.create_next_version(
+                    session,
+                    prompt=self.current_prompt,
+                    user_id=user_id,
+                )
 
             self.last_saved_prompt = self.current_prompt
 
@@ -124,7 +137,18 @@ class SystemPromptState(State):
         self.is_loading = True
         self.error_message = ""
         try:
-            success = await SystemPromptRepository.delete(self.selected_version_id)
+            async with get_asyncdb_session() as session:
+                if self.selected_version_id:
+                    prompt = await system_prompt_repo.find_by_id(
+                        session, self.selected_version_id
+                    )
+                    if prompt:
+                        success = await system_prompt_repo.delete(session, prompt)
+                    else:
+                        success = False
+                else:
+                    success = False
+
             if success:
                 self.selected_version_id = 0
 

appkit_assistant/state/thread_list_state.py

@@ -15,8 +15,9 @@ from typing import TYPE_CHECKING, Any
 
 import reflex as rx
 
-from appkit_assistant.backend.models import ThreadModel
-from appkit_assistant.backend.repositories import ThreadRepository
+from appkit_assistant.backend.models import ThreadModel, ThreadStatus
+from appkit_assistant.backend.repositories import thread_repo
+from appkit_commons.database.session import get_asyncdb_session
 from appkit_user.authentication.states import UserSession
 
 if TYPE_CHECKING:
@@ -124,7 +125,24 @@ class ThreadListState(rx.State):
 
         # Fetch threads from database
         try:
-            threads = await ThreadRepository.get_summaries_by_user(user_id)
+            async with get_asyncdb_session() as session:
+                thread_entities = await thread_repo.find_summaries_by_user(
+                    session, user_id
+                )
+
+                # Convert entities to models inside the session context
+                threads = [
+                    ThreadModel(
+                        thread_id=t.thread_id,
+                        title=t.title,
+                        state=ThreadStatus(t.state),
+                        ai_model=t.ai_model,
+                        active=t.active,
+                        messages=[],
+                    )
+                    for t in thread_entities
+                ]
+
             async with self:
                 self.threads = threads
                 self._initialized = True
@@ -208,7 +226,10 @@ class ThreadListState(rx.State):
 
         try:
             # Delete from database
-            await ThreadRepository.delete_thread(thread_id, user_id)
+            async with get_asyncdb_session() as session:
+                await thread_repo.delete_by_thread_id_and_user(
+                    session, thread_id, user_id
+                )
 
             async with self:
                 # Remove from list

appkit_assistant/state/thread_state.py

@@ -22,6 +22,7 @@ from pydantic import BaseModel
 from appkit_assistant.backend.model_manager import ModelManager
 from appkit_assistant.backend.models import (
     AIModel,
+    AssistantThread,
     Chunk,
     ChunkType,
     MCPServer,
@@ -31,8 +32,9 @@ from appkit_assistant.backend.models import (
     ThreadModel,
     ThreadStatus,
 )
-from appkit_assistant.backend.repositories import MCPServerRepository, ThreadRepository
+from appkit_assistant.backend.repositories import mcp_server_repo, thread_repo
 from appkit_assistant.state.thread_list_state import ThreadListState
+from appkit_commons.database.session import get_asyncdb_session
 from appkit_user.authentication.states import UserSession
 
 logger = logging.getLogger(__name__)
@@ -268,20 +270,41 @@ class ThreadState(rx.State):
             return
 
         try:
-            full_thread = await ThreadRepository.get_thread_by_id(thread_id, user_id)
+            async with get_asyncdb_session() as session:
+                thread_entity = await thread_repo.find_by_thread_id_and_user(
+                    session, thread_id, user_id
+                )
 
-            if not full_thread:
-                logger.warning("Thread %s not found in database", thread_id)
-                async with self:
-                    threadlist_state: ThreadListState = await self.get_state(
-                        ThreadListState
+                if not thread_entity:
+                    logger.warning("Thread %s not found in database", thread_id)
+                    # We can't access self in here easily to clear loading state unless we break out
+                    # but we can check thread_entity after context
+
+                # Convert to ThreadModel if found
+                full_thread = None
+                if thread_entity:
+                    full_thread = ThreadModel(
+                        thread_id=thread_entity.thread_id,
+                        title=thread_entity.title,
+                        state=ThreadStatus(thread_entity.state),
+                        ai_model=thread_entity.ai_model,
+                        active=thread_entity.active,
+                        messages=[Message(**m) for m in thread_entity.messages],
                     )
-                    threadlist_state.loading_thread_id = ""
-                return
+
+            if not full_thread:
+                if not thread_entity:  # it was not found
+                    async with self:
+                        threadlist_state: ThreadListState = await self.get_state(
+                            ThreadListState
+                        )
+                        threadlist_state.loading_thread_id = ""
+                    return
 
             # Mark all messages as done (loaded from DB)
-            for msg in full_thread.messages:
-                msg.done = True
+            if full_thread:
+                for msg in full_thread.messages:
+                    msg.done = True
 
             async with self:
                 # Update self with loaded thread
@@ -355,7 +378,10 @@ class ThreadState(rx.State):
     @rx.event
     async def load_mcp_servers(self) -> None:
         """Load available MCP servers from the database."""
-        self.available_mcp_servers = await MCPServerRepository.get_all()
+        async with get_asyncdb_session() as session:
+            servers = await mcp_server_repo.find_all_ordered_by_name(session)
+            # Create detached copies
+            self.available_mcp_servers = [MCPServer(**s.model_dump()) for s in servers]
 
     @rx.event
     def toogle_tools_modal(self, show: bool) -> None:
@@ -598,7 +624,40 @@ class ThreadState(rx.State):
 
         if user_id:
             try:
-                await ThreadRepository.save_thread(self._thread, user_id)
+                # Prepare entity data
+                messages_dict = [m.dict() for m in self._thread.messages]
+
+                async with get_asyncdb_session() as session:
+                    # Check if exists
+                    existing = await thread_repo.find_by_thread_id_and_user(
+                        session, self._thread.thread_id, user_id
+                    )
+
+                    if existing:
+                        existing.title = self._thread.title
+                        existing.state = (
+                            self._thread.state.value
+                            if hasattr(self._thread.state, "value")
+                            else self._thread.state
+                        )
+                        existing.ai_model = self._thread.ai_model
+                        existing.active = self._thread.active
+                        existing.messages = messages_dict
+                        await thread_repo.save(session, existing)
+                    else:
+                        new_thread = AssistantThread(
+                            thread_id=self._thread.thread_id,
+                            user_id=user_id,
+                            title=self._thread.title,
+                            state=self._thread.state.value
+                            if hasattr(self._thread.state, "value")
+                            else self._thread.state,
+                            ai_model=self._thread.ai_model,
+                            active=self._thread.active,
+                            messages=messages_dict,
+                        )
+                        await thread_repo.save(session, new_thread)
+
                 logger.debug("Saved thread to DB: %s", self._thread.thread_id)
             except Exception as e:
                 logger.error("Error saving thread %s: %s", self._thread.thread_id, e)

{appkit_assistant-0.13.0.dist-info → appkit_assistant-0.14.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: appkit-assistant
-Version: 0.13.0
+Version: 0.14.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
@@ -40,6 +40,7 @@ appkit-assistant provides a complete conversational AI interface built on Reflex
 
 - **Multi-Model Support** - OpenAI Chat Completions, OpenAI Responses API, Perplexity, and fallback Lorem Ipsum processor
 - **MCP Server Integration** - Manage and connect to Model Context Protocol servers as tools
+- **System Prompt Management** - Versioned system prompts with admin editor interface
 - **Secure Credential Management** - Encrypted storage and handling of API keys and server credentials
 - **Reflex UI Components** - Pre-built assistant interface with composer, thread management, and message display
 - **Streaming Responses** - Real-time streaming of AI responses with chunked content
@@ -114,11 +115,11 @@ manager.register_processor("perplexity", PerplexityProcessor(assistant_config))
 
 ```python
 import reflex as rx
-import appkit_assistant as assistant
+from appkit_assistant.components import Assistant
 
 def assistant_page():
     return rx.container(
-        assistant.Assistant(),
+        Assistant(),
         height="100vh"
     )
 ```
@@ -188,10 +189,10 @@ async for chunk in processor.process(messages, "gpt-4", mcp_servers=[mcp_server]
 The main `Assistant` component provides a complete chat interface:
 
 ```python
-import appkit_assistant as assistant
+from appkit_assistant.components import Assistant
 
 def chat_page():
-    return assistant.Assistant()
+    return Assistant()
 ```
 
 #### Individual Components
@@ -199,12 +200,13 @@ def chat_page():
 Use individual components for custom layouts:
 
 ```python
-import appkit_assistant as assistant
+import reflex as rx
+from appkit_assistant.components import ThreadList, composer
 
 def custom_assistant():
     return rx.vstack(
-        assistant.ThreadList(),
-        assistant.composer(),
+        ThreadList(),
+        composer(),
         spacing="4"
     )
 ```
@@ -214,8 +216,21 @@ def custom_assistant():
 Display and manage MCP servers:
 
 ```python
+from appkit_assistant.components import mcp_servers_table
+
 def servers_page():
-    return assistant.mcp_servers_table()
+    return mcp_servers_table()
+```
+
+#### System Prompt Editor
+
+Admin interface for managing versioned system prompts:
+
+```python
+from appkit_assistant.components.system_prompt_editor import system_prompt_editor
+
+def prompt_editor_page():
+    return system_prompt_editor()
 ```
 
 ---
@@ -279,6 +294,8 @@ manager.register_processor("lorem", LoremIpsumProcessor())
 - `ThreadList` - Conversation thread list
 - `MessageComponent` - Individual message display
 - `mcp_servers_table` - MCP server management table
+- `system_prompt_editor` - Admin interface for system prompts
+
 
 ### State Management
 

{appkit_assistant-0.13.0.dist-info → appkit_assistant-0.14.0.dist-info}/RECORD

@@ -2,8 +2,8 @@ appkit_assistant/configuration.py,sha256=3nBL-dEGYsvSnRDNpxtikZn4QMMkMlNbb4VqGOP
 appkit_assistant/backend/model_manager.py,sha256=7f65UbZ51qOYM6F73eKbZ8hMnCzxdanFZKgdKF8bbCk,4366
 appkit_assistant/backend/models.py,sha256=-sr10xChq_lMlLpt7Jbmq4VGweuW4_UUwYsRtIY7HFY,6015
 appkit_assistant/backend/processor.py,sha256=dhBg3pYXdmpj9JtAJc-d83SeUA1NsICj1C_YI0M2QYE,1289
-appkit_assistant/backend/repositories.py,sha256=ueGreZH2ioefwNh1Et5RivDB8IkSLz76aajrWleAVEU,11232
-appkit_assistant/backend/system_prompt_cache.py,sha256=fC2GdTqObfcJdt7nzTUE99GGzX9nLZPCGBUOENcBE5Q,5083
+appkit_assistant/backend/repositories.py,sha256=arYagqYDgn65uFvnFTXP6zaXOn1c3zoAYuPO69-qrSk,5546
+appkit_assistant/backend/system_prompt_cache.py,sha256=4a0sX3qzz3XTF7MX4YJuH29eaekmEx6jciY1zDKcuQ8,5509
 appkit_assistant/backend/processors/lorem_ipsum_processor.py,sha256=j-MZhzibrtabzbGB2Pf4Xcdlr1TlTYWNRdE22LsDp9Q,4635
 appkit_assistant/backend/processors/openai_base.py,sha256=IQS4m375BOD_K0PBFOk4i7wL1z5MEiPFxbSmC-HBNgU,4414
 appkit_assistant/backend/processors/openai_chat_completion_processor.py,sha256=nTxouoXDU6VcQr8UhA2KiMNt60KvIwM8cH9Z8lo4dXY,4218
@@ -12,17 +12,17 @@ appkit_assistant/backend/processors/perplexity_processor.py,sha256=weHukv78MSCF_
 appkit_assistant/components/__init__.py,sha256=5tzK5VjX9FGKK-qTUHLjr8-ohT4ykb4a-zC-I3yeRLY,916
 appkit_assistant/components/composer.py,sha256=F4VPxWp4P6fvTW4rQ7S-YWn0eje5c3jGsWrpC1aewss,3885
 appkit_assistant/components/composer_key_handler.py,sha256=KyZYyhxzFR8DH_7F_DrvTFNT6v5kG6JihlGTmCv2wv0,1028
-appkit_assistant/components/mcp_server_dialogs.py,sha256=wRfQQKJ28z-kz2aO7R2N5D958y7cU9qdx9R_ZuRNS0I,11441
+appkit_assistant/components/mcp_server_dialogs.py,sha256=00BL6xdHeWcW1MMGJrmUFjiZ-Ksa22L-lydqPihZJwk,11451
 appkit_assistant/components/mcp_server_table.py,sha256=1dziN7hDDvE8Y3XcdIs0wUPv1H64kP9gRAEjgH9Yvzo,2323
 appkit_assistant/components/message.py,sha256=Tr19CsRqKiMP_fhSByVlUtigeXF13duR6Rp2mQ08IeQ,9636
 appkit_assistant/components/system_prompt_editor.py,sha256=REl33zFmcpYRe9kxvFrBRYg40dV4L4FtVC_3ibLsmrU,2940
 appkit_assistant/components/thread.py,sha256=rYM4LA6PVdEvZ5oz5ZtheVfQfFuvTXTIskTt15kI1kg,7886
 appkit_assistant/components/threadlist.py,sha256=1xVakSTQYi5-wgED3fTJVggeIjL_fkthehce0wKUYtM,4896
 appkit_assistant/components/tools_modal.py,sha256=12iiAVahy3j4JwjGfRlegVEa4ePhGsEu7Bq92JLn1ZI,3353
-appkit_assistant/state/mcp_server_state.py,sha256=L5r3Bd_OzFh_kgWH81cKVBWhE3Ys6m8TsJs2vadCWhU,7945
-appkit_assistant/state/system_prompt_state.py,sha256=cNjjCOHir5sYgsmd5Cv-lAkAIYesKr_jbgQD1Jyuqu0,6620
-appkit_assistant/state/thread_list_state.py,sha256=fQcMy4SZbum1YcbXJ7XFAsZRIeFS-l8BFeNVy01M1Iw,9445
-appkit_assistant/state/thread_state.py,sha256=qImM6x49--0XYonzwgExrpMy7lcgbKtToH_441iP9Gk,29050
-appkit_assistant-0.13.0.dist-info/METADATA,sha256=XgkrLY4iybvzRXs9PMlKwuz1T4kvx01MDcxCrq9_my8,8934
-appkit_assistant-0.13.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-appkit_assistant-0.13.0.dist-info/RECORD,,
+appkit_assistant/state/mcp_server_state.py,sha256=DJJ9LVIMk-RXio-BbeZv6J9eShqg_dNANDdINkZECpc,9287
+appkit_assistant/state/system_prompt_state.py,sha256=iwjz3ABr1GGFau7sTP3c-5vfc0VYer_1mPbBNhOZsys,7701
+appkit_assistant/state/thread_list_state.py,sha256=uDWPJ82ZqSSj8jos1P2NmbRSm-BZz5xwenl9aMzrpHo,10230
+appkit_assistant/state/thread_state.py,sha256=8nAALYOa55GVoonVcf57rusUcsVEatn-zcofeLdBtfk,31882
+appkit_assistant-0.14.0.dist-info/METADATA,sha256=pG1dZK1hqKJf-suHF4nAnq9kJUw8bbqMyJiUIyV1sXg,9403
+appkit_assistant-0.14.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+appkit_assistant-0.14.0.dist-info/RECORD,,