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

appkit_assistant/backend/models.py

@@ -1,11 +1,34 @@
-from datetime import datetime
+import json
+from datetime import UTC, datetime
 from enum import StrEnum
+from typing import Any
 
 import reflex as rx
 from pydantic import BaseModel
+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):
@@ -40,6 +63,7 @@ class ThreadStatus(StrEnum):
     ACTIVE = "active"
     IDLE = "idle"
     WAITING = "waiting"
+    ERROR = "error"
     DELETED = "deleted"
     ARCHIVED = "archived"
 
@@ -104,7 +128,7 @@ class MCPAuthType(StrEnum):
 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)
@@ -139,7 +163,7 @@ class SystemPrompt(rx.Model, table=True):
     Each save creates a new immutable version. Supports up to 20,000 characters.
     """
 
-    __tablename__ = "system_prompt"
+    __tablename__ = "assistant_system_prompt"
 
     id: int | None = Field(default=None, primary_key=True)
     name: str = Field(max_length=200, nullable=False)
@@ -147,3 +171,26 @@ class SystemPrompt(rx.Model, table=True):
     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

@@ -454,7 +454,10 @@ class OpenAIResponsesProcessor(BaseOpenAIProcessor):
         return tools, prompt_string
 
     async def _convert_messages_to_responses_format(
-        self, messages: list[Message], mcp_prompt: str = ""
+        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,14 +474,15 @@ class OpenAIResponsesProcessor(BaseOpenAIProcessor):
         else:
             mcp_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}],
-            }
-        )
+        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

@@ -4,8 +4,16 @@ import logging
 from datetime import UTC, datetime
 
 import reflex as rx
+from sqlalchemy.orm import defer
 
-from appkit_assistant.backend.models import MCPServer, SystemPrompt
+from appkit_assistant.backend.models import (
+    AssistantThread,
+    MCPServer,
+    Message,
+    SystemPrompt,
+    ThreadModel,
+    ThreadStatus,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -181,3 +189,135 @@ class SystemPromptRepository:
                 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/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,

appkit_assistant/components/thread.py

@@ -4,15 +4,11 @@ from collections.abc import Callable
 import reflex as rx
 
 import appkit_mantine as mn
+from appkit_assistant.backend.models import Message, MessageType
 from appkit_assistant.components import composer
 from appkit_assistant.components.message import MessageComponent
 from appkit_assistant.components.threadlist import ThreadList
-from appkit_assistant.state.thread_state import (
-    Message,
-    MessageType,
-    ThreadListState,
-    ThreadState,
-)
+from appkit_assistant.state.thread_state import ThreadState
 
 logger = logging.getLogger(__name__)
 
@@ -55,7 +51,7 @@ class Assistant:
                         lambda suggestion: Assistant.suggestion(
                             prompt=suggestion.prompt,
                             icon=suggestion.icon,
-                            update_prompt=ThreadState.update_prompt,
+                            update_prompt=ThreadState.set_prompt,
                         ),
                     ),
                     spacing="4",
@@ -122,7 +118,7 @@ class Assistant:
                 ),
                 rx.hstack(
                     composer.tools(
-                        show=with_tools and ThreadState.current_model_supports_tools
+                        show=with_tools and ThreadState.selected_model_supports_tools
                     ),
                     composer.add_attachment(show=with_attachments),
                     composer.clear(show=with_clear),
@@ -156,9 +152,6 @@ class Assistant:
         # if suggestions is not None:
         #     ThreadState.set_suggestions(suggestions)
 
-        if with_thread_list:
-            ThreadState.with_thread_list = with_thread_list
-
         return rx.flex(
             rx.cond(
                 ThreadState.messages,
@@ -207,7 +200,10 @@ class Assistant:
                 spacing="0",
                 flex_shrink=0,
                 z_index=1000,
-                on_mount=ThreadState.load_available_mcp_servers,
+                on_mount=[
+                    ThreadState.set_with_thread_list(with_thread_list),
+                    ThreadState.load_mcp_servers,
+                ],
             ),
             **props,
         )
@@ -216,12 +212,8 @@ class Assistant:
     def thread_list(
         *items,
         with_footer: bool = False,
-        default_model: str | None = None,
         **props,
     ) -> rx.Component:
-        if default_model:
-            ThreadListState.default_model = default_model
-
         return rx.flex(
             rx.flex(
                 ThreadList.header(

appkit_assistant/components/threadlist.py

@@ -1,6 +1,8 @@
 import reflex as rx
 
-from appkit_assistant.state.thread_state import ThreadListState, ThreadModel
+from appkit_assistant.backend.models import ThreadModel
+from appkit_assistant.state.thread_list_state import ThreadListState
+from appkit_assistant.state.thread_state import ThreadState
 
 
 class ThreadList:
@@ -13,7 +15,7 @@ class ThreadList:
                     rx.text(title),
                     size="2",
                     margin_right="28px",
-                    on_click=ThreadListState.create_thread(),
+                    on_click=ThreadState.new_thread(),
                     width="95%",
                 ),
                 content="Neuen Chat starten",
@@ -46,24 +48,28 @@ class ThreadList:
                 min_width="0",
                 title=thread.title,
             ),
-            rx.tooltip(
-                rx.button(
-                    rx.icon(
-                        "trash",
-                        size=13,
-                        stroke_width=1.5,
+            rx.cond(
+                ThreadListState.loading_thread_id == thread.thread_id,
+                rx.spinner(size="1", margin_left="6px", margin_right="6px"),
+                rx.tooltip(
+                    rx.button(
+                        rx.icon(
+                            "trash",
+                            size=13,
+                            stroke_width=1.5,
+                        ),
+                        variant="ghost",
+                        size="1",
+                        margin_left="0px",
+                        margin_right="0px",
+                        color_scheme="gray",
+                        on_click=ThreadListState.delete_thread(thread.thread_id),
                     ),
-                    variant="ghost",
-                    size="1",
-                    margin_left="0px",
-                    margin_right="0px",
-                    color_scheme="gray",
-                    on_click=ThreadListState.delete_thread(thread.thread_id),
+                    content="Chat löschen",
+                    flex_shrink=0,
                 ),
-                content="Chat löschen",
-                flex_shrink=0,
             ),
-            on_click=ThreadListState.select_thread(thread.thread_id),
+            on_click=ThreadState.load_thread(thread.thread_id),
             flex_direction=["row"],
             margin_right="10px",
             margin_bottom="8px",
@@ -113,18 +119,25 @@ class ThreadList:
                     ThreadListState.threads,
                     ThreadList.thread_list_item,
                 ),
-                rx.text(
-                    "Keine Chats vorhanden.",
-                    size="2",
-                    white_space="nowrap",
-                    overflow="hidden",
-                    text_overflow="ellipsis",
-                    flex_grow="1",
-                    min_width="0",
-                    margin_right="10px",
-                    margin_bottom="8px",
-                    padding="6px",
-                    align="center",
+                rx.cond(
+                    ThreadListState.loading,
+                    rx.vstack(
+                        rx.skeleton(height="34px", width="210px"),
+                        rx.skeleton(height="34px", width="210px"),
+                        rx.skeleton(height="34px", width="210px"),
+                        spacing="2",
+                    ),
+                    rx.text(
+                        "Noch keine Chats vorhanden. "
+                        "Klicke auf 'Neuer Chat', um zu beginnen.",
+                        size="2",
+                        flex_grow="1",
+                        min_width="0",
+                        margin_right="10px",
+                        margin_bottom="8px",
+                        padding="6px",
+                        align="center",
+                    ),
                 ),
             ),
             scrollbars="vertical",

appkit_assistant/components/tools_modal.py

@@ -92,6 +92,6 @@ def tools_popover() -> rx.Component:
             side="top",
         ),
         open=ThreadState.show_tools_modal,
-        on_open_change=ThreadState.set_show_tools_modal,
+        on_open_change=ThreadState.toogle_tools_modal,
         placement="bottom-start",
     )

appkit_assistant/configuration.py

@@ -8,3 +8,4 @@ class AssistantConfig(BaseConfig):
     openai_base_url: str | None = None
     openai_api_key: SecretStr | None = None
     google_api_key: SecretStr | None = None
+    azure_ai_projects_endpoint: str | None = None

appkit_assistant/state/system_prompt_state.py

@@ -25,7 +25,6 @@ class SystemPromptState(State):
     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:
@@ -45,12 +44,10 @@ class SystemPromptState(State):
                 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:
@@ -64,8 +61,9 @@ class SystemPromptState(State):
                     self.current_prompt = ""
                 self.last_saved_prompt = self.current_prompt
 
-            # Zähler initial setzen
             self.char_count = len(self.current_prompt)
+            # Force textarea to re-render with loaded content
+            self.textarea_key += 1
 
             logger.info("Loaded %s system prompt versions", len(self.versions))
         except Exception as exc: