appkit-assistant 0.7.1__py3-none-any.whl

appkit_assistant/backend/model_manager.py

@@ -0,0 +1,133 @@
+import logging
+import threading
+from typing import Optional
+
+from appkit_assistant.backend.models import AIModel
+from appkit_assistant.backend.processor import Processor
+
+logger = logging.getLogger(__name__)
+
+
+class ModelManager:
+    """Singleton service manager for AI processing services."""
+
+    _instance: Optional["ModelManager"] = None
+    _lock = threading.Lock()
+    _default_model_id = (
+        None  # Default model ID will be set to the first registered model
+    )
+
+    def __new__(cls) -> "ModelManager":
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super(ModelManager, cls).__new__(cls)  # noqa UP008
+        return cls._instance
+
+    def __init__(self):
+        """Initialize the service manager if not already initialized."""
+        if not hasattr(self, "_initialized"):
+            self._processors: dict[str, Processor] = {}
+            self._models: dict[str, AIModel] = {}
+            self._model_to_processor: dict[str, str] = {}
+            self._initialized = True
+            logger.debug("ModelManager initialized")
+
+    def register_processor(self, processor_name: str, processor: Processor) -> None:
+        """
+        Register a processor with the service manager.
+
+        Args:
+            processor_name: Name of the processor.
+            processor: Instance of a Processor.
+        """
+        self._processors[processor_name] = processor
+
+        # Extract and register all models supported by this processor
+        supported_models = processor.get_supported_models()
+        for model_id, model in supported_models.items():
+            if model_id not in self._models:
+                self._models[model_id] = model
+                self._model_to_processor[model_id] = processor_name
+
+                # Set the first registered model as default if no default is set
+                if self._default_model_id is None:
+                    self._default_model_id = model_id
+                    logger.debug("Set first model %s as default", model_id)
+
+        logger.debug("Registered processor: %s", processor_name)
+
+    def get_processor_for_model(self, model_id: str) -> Processor | None:
+        """
+        Get the processor that supports the specified model.
+
+        Args:
+            model_id: ID of the model.
+
+        Returns:
+            The processor that supports the model or None if no processor is found.
+        """
+        processor_name = self._model_to_processor.get(model_id)
+        if processor_name:
+            return self._processors.get(processor_name)
+        return None
+
+    def get_all_models(self) -> list[AIModel]:
+        """
+        Get all registered models.
+
+        Returns:
+            List of all models.
+        """
+        return sorted(
+            self._models.values(),
+            key=lambda model: (
+                model.icon.lower() if model.icon else "",
+                model.text.lower(),
+            ),
+        )
+
+    def get_model(self, model_id: str) -> AIModel | None:
+        """
+        Get a model by its ID.
+
+        Args:
+            model_id: ID of the model.
+
+        Returns:
+            The model or None if not found.
+        """
+        return self._models.get(model_id)
+
+    def get_default_model(self) -> str:
+        """
+        Get the default model ID.
+
+        Returns:
+            The default model ID as a string.
+        """
+        if self._default_model_id is None:
+            if self._models:
+                self._default_model_id = next(iter(self._models.keys()))
+                logger.debug(
+                    "Using first available model %s as default", self._default_model_id
+                )
+            else:
+                logger.warning("No models registered, returning fallback model name")
+                return "default"
+        return self._default_model_id
+
+    def set_default_model(self, model_id: str) -> None:
+        """
+        Set the default model ID.
+
+        Args:
+            model_id: ID of the model to set as default.
+        """
+        if model_id in self._models:
+            self._default_model_id = model_id
+            logger.debug("Default model set to: %s", model_id)
+        else:
+            logger.warning(
+                "Attempted to set unregistered model %s as default. Ignoring.", model_id
+            )

appkit_assistant/backend/models.py

@@ -0,0 +1,103 @@
+from enum import StrEnum
+
+import reflex as rx
+from pydantic import BaseModel
+from sqlmodel import Field
+
+from appkit_commons.database.entities import EncryptedString
+
+
+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"
+    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
+
+
+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 MCPServer(rx.Model, table=True):
+    """Model for MCP (Model Context Protocol) server configuration."""
+
+    __tablename__ = "mcp_server"
+
+    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)

appkit_assistant/backend/processor.py

@@ -0,0 +1,46 @@
+"""
+Base processor interface for AI processing services.
+"""
+
+import abc
+import logging
+from collections.abc import AsyncGenerator
+
+from appkit_assistant.backend.models import AIModel, Chunk, MCPServer, Message
+
+logger = logging.getLogger(__name__)
+
+
+class Processor(abc.ABC):
+    """Base processor interface for AI processing services."""
+
+    @abc.abstractmethod
+    async def process(
+        self,
+        messages: list[Message],
+        model_id: str,
+        files: list[str] | None = None,
+        mcp_servers: list[MCPServer] | None = None,
+    ) -> AsyncGenerator[Chunk, None]:
+        """
+        Process the thread using an AI model.
+
+        Args:
+            messages: The list of messages to process.
+            model_id: The ID of the model to use.
+            files: Optional list of file paths that were uploaded.
+            mcp_servers: Optional list of MCP servers to use as tools.
+
+        Returns:
+            An async generator that yields Chunk objects containing different content
+            types.
+        """
+
+    @abc.abstractmethod
+    def get_supported_models(self) -> dict[str, AIModel]:
+        """
+        Get a dictionary of models supported by this processor.
+
+        Returns:
+            Dictionary mapping model IDs to AIModel objects.
+        """

appkit_assistant/backend/processors/ai_models.py

@@ -0,0 +1,109 @@
+from typing import Final
+
+from appkit_assistant.backend.models import AIModel
+
+DEFAULT: Final = AIModel(
+    id="default",
+    text="Default (GPT 4.1 Mini)",
+    icon="avvia_intelligence",
+    model="default",
+    stream=True,
+)
+
+GEMINI_2_5_FLASH: Final = AIModel(
+    id="gemini-2-5-flash",
+    text="Gemini 2.5 Flash",
+    icon="googlegemini",
+    model="gemini-2-5-flash",
+)
+LLAMA_3_2_VISION: Final = AIModel(
+    id="llama32_vision_90b",
+    text="Llama 3.2 Vision 90B (OnPrem)",
+    icon="ollama",
+    model="lllama32_vision_90b",
+)
+
+GPT_4o: Final = AIModel(
+    id="gpt-4o",
+    text="GPT 4o",
+    icon="openai",
+    model="gpt-4o",
+    stream=True,
+    supports_attachments=True,
+    supports_tools=True,
+)
+
+GPT_4_1: Final = AIModel(
+    id="gpt-4.1",
+    text="GPT-4.1",
+    icon="openai",
+    model="gpt-4.1",
+    stream=True,
+    supports_attachments=True,
+    supports_tools=True,
+)
+
+O3: Final = AIModel(
+    id="o3",
+    text="o3 Reasoning",
+    icon="openai",
+    model="o3",
+    temperature=1,
+    stream=True,
+    supports_attachments=True,
+    supports_tools=True,
+)
+
+O4_MINI: Final = AIModel(
+    id="o4-mini",
+    text="o4 Mini Reasoning",
+    icon="openai",
+    model="o4-mini",
+    stream=True,
+    supports_attachments=True,
+    supports_tools=True,
+    temperature=1,
+)
+
+GPT_5: Final = AIModel(
+    id="gpt-5",
+    text="GPT 5",
+    icon="openai",
+    model="gpt-5",
+    stream=True,
+    supports_attachments=True,
+    supports_tools=True,
+    temperature=1,
+)
+
+GPT_5_CHAT: Final = AIModel(
+    id="gpt-5-chat",
+    text="GPT 5 Chat",
+    icon="openai",
+    model="gpt-5-chat",
+    stream=True,
+    supports_attachments=True,
+    supports_tools=False,
+)
+
+GPT_5_MINI: Final = AIModel(
+    id="gpt-5-mini",
+    text="GPT 5 Mini",
+    icon="openai",
+    model="gpt-5-mini",
+    stream=True,
+    supports_attachments=True,
+    supports_tools=True,
+    temperature=1,
+)
+
+GPT_5_NANO: Final = AIModel(
+    id="gpt-5-nano",
+    text="GPT 5 Nano",
+    icon="openai",
+    model="gpt-5-nano",
+    stream=True,
+    supports_attachments=True,
+    supports_tools=True,
+    temperature=1,
+)

appkit_assistant/backend/processors/knowledgeai_processor.py

@@ -0,0 +1,275 @@
+import asyncio
+import logging
+from collections.abc import AsyncGenerator
+from typing import Any
+
+from openai import AsyncOpenAI, AsyncStream
+from openai.types.chat import ChatCompletionMessageParam
+
+from appkit_assistant.backend.models import (
+    AIModel,
+    Chunk,
+    ChunkType,
+    MCPServer,
+    Message,
+    MessageType,
+)
+from appkit_assistant.backend.processor import Processor
+
+logger = logging.getLogger(__name__)
+
+
+class KnowledgeAIProcessor(Processor):
+    """Processor that generates Knowledge AI text responses."""
+
+    def __init__(
+        self,
+        server: str,
+        api_key: str,
+        models: dict[str, AIModel] | None = None,
+        with_projects: bool = False,
+    ) -> None:
+        """Initialize the Knowledge AI processor."""
+        super().__init__()
+        self.api_key = api_key
+        self.server = server
+        self.models = models
+        self.with_projects = with_projects
+
+        if with_projects:
+            self._initialize_models()
+
+    def _initialize_models(self) -> None:
+        """Initialize the models supported by this processor."""
+        try:
+            from knai_avvia.backend.models import Project  # noqa: PLC0415
+            from knai_avvia.backend.project_repository import (  # noqa: PLC0415
+                load_projects,  # noqa: E402
+            )
+        except ImportError as e:
+            logger.error("knai_avvia package not available: %s", e)
+            self.models = {}
+            return
+
+        try:
+            projects: list[Project] = asyncio.run(
+                load_projects(
+                    url=self.server,
+                    api_key=self.api_key,
+                )
+            )
+
+            if self.models is None:
+                self.models = {}
+
+            for project in projects:
+                project_key = f"{project.id}"
+                self.models[project_key] = AIModel(
+                    id=project_key,
+                    text=project.name,
+                    icon="avvia_intelligence",
+                )
+        except Exception as e:
+            logger.error("Failed to load projects from Knowledge AI: %s", e)
+            self.models = {}
+
+    async def process(
+        self,
+        messages: list[Message],
+        model_id: str,
+        files: list[str] | None = None,  # noqa: ARG002
+        mcp_servers: list[MCPServer] | None = None,  # noqa: ARG002
+    ) -> AsyncGenerator[Chunk, None]:
+        try:
+            from knai_avvia.backend.chat_client import chat_completion  # noqa: PLC0415
+        except ImportError as e:
+            logger.error("knai_avvia package not available: %s", e)
+            raise ImportError(
+                "knai_avvia package is required for KnowledgeAIProcessor"
+            ) from e
+
+        if model_id not in self.models:
+            logger.error("Model %s not supported by OpenAI processor", model_id)
+            raise ValueError(f"Model {model_id} not supported by OpenAI processor")
+
+        chat_messages = self._convert_messages(messages)
+
+        try:
+            result = await chat_completion(
+                api_key=self.api_key,
+                server=self.server,
+                project_id=int(model_id),
+                question=messages[-2].text,  # last human message
+                history=chat_messages,
+                temperature=0.05,
+            )
+
+            if result.answer:
+                yield Chunk(
+                    type=ChunkType.TEXT,
+                    text=result.answer,
+                    chunk_metadata={
+                        "source": "knowledgeai",
+                        "project_id": model_id,
+                        "streaming": str(False),
+                    },
+                )
+        except Exception as e:
+            raise e
+
+    def get_supported_models(self) -> dict[str, AIModel]:
+        return self.models if self.api_key else {}
+
+    def _convert_messages(self, messages: list[Message]) -> list[dict[str, str]]:
+        return [
+            {"role": "Human", "message": msg.text}
+            if msg.type == MessageType.HUMAN
+            else {"role": "AI", "message": msg.text}
+            for msg in (messages or [])
+            if msg.type in (MessageType.HUMAN, MessageType.ASSISTANT)
+        ]
+
+
+class KnowledgeAIOpenAIProcessor(Processor):
+    """Processor that generates Knowledge AI text responses."""
+
+    def __init__(
+        self,
+        server: str,
+        api_key: str,
+        models: dict[str, AIModel] | None = None,
+        with_projects: bool = False,
+    ) -> None:
+        """Initialize the Knowledge AI processor."""
+        self.api_key = api_key
+        self.server = server
+        self.models = models
+        self.with_projects = with_projects
+        self.client = (
+            AsyncOpenAI(api_key=self.api_key, base_url=self.server + "/api/openai/v1")
+            if self.api_key
+            else None
+        )
+
+        if self.with_projects:
+            self._initialize_models()
+
+    def _initialize_models(self) -> None:
+        """Initialize the models supported by this processor."""
+        try:
+            from knai_avvia.backend.models import Project  # noqa: PLC0415
+            from knai_avvia.backend.project_repository import (  # noqa: PLC0415
+                load_projects,  # noqa: E402
+            )
+        except ImportError as e:
+            logger.error("knai_avvia package not available: %s", e)
+            self.models = {}
+            return
+
+        try:
+            projects: list[Project] = asyncio.run(
+                load_projects(
+                    url=self.server,
+                    api_key=self.api_key,
+                )
+            )
+
+            if self.models is None:
+                self.models = {}
+
+            for project in projects:
+                project_key = f"{project.id}"
+                self.models[project_key] = AIModel(
+                    id=project_key,
+                    project_id=project.id,
+                    text=project.name,
+                    icon="avvia_intelligence",
+                    stream=False,
+                )
+        except Exception as e:
+            logger.error("Failed to load projects from Knowledge AI: %s", e)
+            self.models = {}
+
+    async def process(
+        self,
+        messages: list[Message],
+        model_id: str,
+        files: list[str] | None = None,  # noqa: ARG002
+        mcp_servers: list[MCPServer] | None = None,  # noqa: ARG002
+    ) -> AsyncGenerator[Chunk, None]:
+        if not self.client:
+            raise ValueError("KnowledgeAI OpenAI Client not initialized.")
+
+        model = self.models.get(model_id)
+        if not model:
+            raise ValueError(
+                "Model %s not supported by KnowledgeAI processor", model_id
+            )
+
+        chat_messages = self._convert_messages_to_openai_format(messages)
+
+        try:
+            session_params: dict[str, Any] = {
+                "model": model.model if model.project_id else model.id,
+                "messages": chat_messages[:-1],
+                "stream": model.stream,
+            }
+            if model.project_id:
+                session_params["user"] = str(model.project_id)
+
+            session = await self.client.chat.completions.create(**session_params)
+
+            if isinstance(session, AsyncStream):
+                async for event in session:
+                    if event.choices and event.choices[0].delta:
+                        content = event.choices[0].delta.content
+                        if content:
+                            yield Chunk(
+                                type=ChunkType.TEXT,
+                                text=content,
+                                chunk_metadata={
+                                    "source": "knowledgeai_openai",
+                                    "streaming": str(True),
+                                    "model_id": model_id,
+                                },
+                            )
+            elif session.choices and session.choices[0].message:
+                content = session.choices[0].message.content
+                if content:
+                    logger.debug("Content:\n%s", content)
+                    yield Chunk(
+                        type=ChunkType.TEXT,
+                        text=content,
+                        chunk_metadata={
+                            "source": "knowledgeai_openai",
+                            "streaming": str(False),
+                            "model_id": model_id,
+                        },
+                    )
+        except Exception as e:
+            logger.exception("Failed to get response from OpenAI: %s", e)
+            raise e
+
+    def get_supported_models(self) -> dict[str, AIModel]:
+        return self.models if self.api_key else {}
+
+    def _convert_messages_to_openai_format(
+        self, messages: list[Message]
+    ) -> list[ChatCompletionMessageParam]:
+        formatted: list[ChatCompletionMessageParam] = []
+        role_map = {
+            MessageType.HUMAN: "user",
+            MessageType.SYSTEM: "system",
+            MessageType.ASSISTANT: "assistant",
+        }
+
+        for msg in messages or []:
+            if msg.type not in role_map:
+                continue
+            role = role_map[msg.type]
+            if formatted and role != "system" and formatted[-1]["role"] == role:
+                formatted[-1]["content"] = formatted[-1]["content"] + "\n\n" + msg.text
+            else:
+                formatted.append({"role": role, "content": msg.text})
+
+        return formatted