appkit-assistant 0.8.0__tar.gz → 0.10.0__tar.gz

{appkit_assistant-0.8.0 → appkit_assistant-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: appkit-assistant
-Version: 0.8.0
+Version: 0.10.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
@@ -20,7 +20,7 @@ Requires-Dist: appkit-commons
 Requires-Dist: appkit-mantine
 Requires-Dist: appkit-ui
 Requires-Dist: openai>=2.3.0
-Requires-Dist: reflex>=0.8.20
+Requires-Dist: reflex>=0.8.22
 Description-Content-Type: text/markdown
 
 # appkit-assistant

{appkit_assistant-0.8.0 → appkit_assistant-0.10.0}/pyproject.toml

@@ -1,6 +1,13 @@
 [project]
+dependencies = [
+    "appkit-commons",
+    "appkit-mantine",
+    "appkit-ui",
+    "openai>=2.3.0",
+    "reflex>=0.8.22",
+]
 name = "appkit-assistant"
-version = "0.8.0"
+version = "0.10.0"
 description = "Add your description here"
 readme = "README.md"
 authors = [{ name = "Jens Rehpöhler" }]
@@ -21,13 +28,6 @@ classifiers = [
     "Topic :: Software Development :: Libraries :: Python Modules",
     "Topic :: Software Development :: User Interfaces",
 ]
-dependencies = [
-    "appkit-commons",
-    "appkit-mantine",
-    "appkit-ui",
-    "openai>=2.3.0",
-    "reflex>=0.8.20",
-]
 
 [project.urls]
 Homepage = "https://github.com/jenreh/appkit"

appkit_assistant-0.10.0/src/appkit_assistant/backend/models.py

@@ -0,0 +1,196 @@
+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):
+    """Enum for chunk types."""
+
+    TEXT = "text"  # default
+    ANNOTATION = "annotation"  # for text annotations
+    IMAGE = "image"
+    IMAGE_PARTIAL = "image_partial"  # for streaming image generation
+    THINKING = "thinking"  # when the model is "thinking" / reasoning
+    THINKING_RESULT = "thinking_result"  # when the "thinking" is done
+    ACTION = "action"  # when the user needs to take action
+    TOOL_RESULT = "tool_result"  # result from a tool
+    TOOL_CALL = "tool_call"  # calling a tool
+    COMPLETION = "completion"  # when response generation is complete
+    ERROR = "error"  # when an error occurs
+    LIFECYCLE = "lifecycle"
+
+
+class Chunk(BaseModel):
+    """Model for text chunks."""
+
+    type: ChunkType
+    text: str
+    chunk_metadata: dict[str, str] = {}
+
+
+class ThreadStatus(StrEnum):
+    """Enum for thread status."""
+
+    NEW = "new"
+    ACTIVE = "active"
+    IDLE = "idle"
+    WAITING = "waiting"
+    ERROR = "error"
+    DELETED = "deleted"
+    ARCHIVED = "archived"
+
+
+class MessageType(StrEnum):
+    """Enum for message types."""
+
+    HUMAN = "human"
+    SYSTEM = "system"
+    ASSISTANT = "assistant"
+    TOOL_USE = "tool_use"
+    ERROR = "error"
+    INFO = "info"
+    WARNING = "warning"
+
+
+class Message(BaseModel):
+    text: str
+    editable: bool = False
+    type: MessageType
+    done: bool = False
+
+
+class AIModel(BaseModel):
+    id: str
+    text: str
+    icon: str = "codesandbox"
+    stream: bool = False
+    tenant_key: str = ""
+    project_id: int = 0
+    model: str = "default"
+    temperature: float = 0.05
+    supports_tools: bool = False
+    supports_attachments: bool = False
+    keywords: list[str] = []
+    disabled: bool = False
+
+
+class Suggestion(BaseModel):
+    prompt: str
+    icon: str = ""
+
+
+class ThreadModel(BaseModel):
+    thread_id: str
+    title: str = ""
+    active: bool = False
+    state: ThreadStatus = ThreadStatus.NEW
+    prompt: str | None = ""
+    messages: list[Message] = []
+    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__ = "assistant_mcp_servers"
+
+    id: int | None = Field(default=None, primary_key=True)
+    name: str = Field(unique=True, max_length=100, nullable=False)
+    description: str = Field(default="", max_length=255, nullable=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-0.8.0 → appkit_assistant-0.10.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,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-0.10.0/src/appkit_assistant/backend/repositories.py

@@ -0,0 +1,323 @@
+"""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 (
+    AssistantThread,
+    MCPServer,
+    Message,
+    SystemPrompt,
+    ThreadModel,
+    ThreadStatus,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class MCPServerRepository:
+    """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
+
+    @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
+
+
+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],
+            )