appkit-assistant 0.7.0__tar.gz

appkit_assistant-0.7.0/.gitignore

@@ -0,0 +1,114 @@
+__pycache__/
+__pypackages__/
+.cache
+.coverage
+.coverage.*
+.dmypy.json
+.DS_Store
+.eggs/
+.env
+.env.backup
+.env.docker
+.hypothesis/
+.idea/
+.installed.cfg
+.ipynb_checkpoints
+.mypy_cache/
+.nox/
+.pdm.toml
+.pybuilder/
+.pyre/
+.pytest_cache/
+.Python
+.python_packages
+.pytype/
+.ropeproject
+.scrapy
+.spyderproject
+.spyproject
+.states
+.tox/
+.venv
+.venv.mac
+.web
+.webassets-cache
+*.bak
+*.cover
+*.db
+*.egg
+*.egg-info/
+*.kv-env.*
+*.log
+*.manifest
+*.mo
+*.pot
+*.py,cover
+*.py[cod]
+*.sage.py
+*.so
+*.spec
+*.terraform.lock.hcl
+*.tfplan
+*.tfstate
+*.tfstate.*.backup
+*.tfstate.backup
+*.tfvars
+**/.terraform/*
+*$py.class
+/site
+/vectorstore/
+aila-storage/
+assets/external/
+build/
+celerybeat-schedule
+celerybeat.pid
+configuration/config.abaz009.yaml
+configuration/config.bubb001.yaml
+configuration/config.stie104.yaml
+configuration/config.voro047.yaml
+connector examples/sharepoint.json
+cover/
+coverage.xml
+cython_debug/
+db.sqlite3
+db.sqlite3-journal
+develop-eggs/
+dist/
+dmypy.json
+docs/_build/
+Documents/
+downloads/
+eggs/
+env.bak/
+env/
+ENV/
+htmlcov/
+instance/
+ipython_config.py
+knowledge/migrate.py
+lib/
+lib64/
+local_settings.py
+local.settings.json
+MANIFEST
+nosetests.xml
+out
+parts/
+pip-delete-this-directory.txt
+pip-log.txt
+Pipfile
+profile_default/
+sdist/
+share/python-wheels/
+sketchpad/
+sketchpad/
+stores/
+target/
+tests/mcp_test.py
+tmp.txt
+uploaded_files/
+uploads/
+var/
+venv.bak/
+venv/
+wheels/

appkit_assistant-0.7.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: appkit-assistant
+Version: 0.7.0
+Summary: Add your description here
+Author: Jens Rehpöhler
+Requires-Python: >=3.13
+Requires-Dist: appkit-commons
+Requires-Dist: openai>=2.3.0

appkit_assistant-0.7.0/docs/ideas.md

@@ -0,0 +1,67 @@
+# Render information with a dedicated UI
+
+"Action" classes, e.g. something like
+
+```python
+class Calender(AssitantAction):
+   name: str
+   description: str
+   parameters: list[dict]
+
+   def __init__(self):
+      name = "showCalendarMeeting"
+      description = "Displays calendar meeting information"
+      parameters = [
+        {
+            name: "date",
+            type: "string",
+            description: "Meeting date (YYYY-MM-DD)",
+            required: true
+        },
+        {
+            name: "time",
+            type: "string",
+            description: "Meeting time (HH:mm)",
+            required: true
+        },
+        {
+            name: "meetingName",
+            type: "string",
+            description: "Name of the meeting",
+            required: false
+        }
+    ]
+
+    def render(status, **kwargs):
+       if status == Status.LOADING:
+          return loading_view()
+       else:
+          return calendar_entry(**kwargs)
+```
+
+## Next Actions
+
+```python
+class Suggestion(AssitantAction):
+   name: str
+   description: str
+   parameters: list[dict]
+
+   def __init__(self):
+      name = "showSuggestion"
+      description = "Displays suggestions"
+      parameters = [
+        {
+            name: "suggestion",
+            type: "string",
+            description: "Suggestion what how to continue or what to ask next",
+            required: false
+        }
+    ]
+
+    def render(status, **kwargs):
+       if status == Status.LOADING:
+          return loading_view()
+       else:
+          return render_suggestion(**kwargs)
+```

appkit_assistant-0.7.0/pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "appkit-assistant"
+version = "0.7.0"
+description = "Add your description here"
+readme = "README.md"
+authors = [{ name = "Jens Rehpöhler" }]
+requires-python = ">=3.13"
+dependencies = [
+    "appkit-commons",
+    "openai>=2.3.0",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.uv.sources]
+appkit-commons = { workspace = true }
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/appkit_assistant"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

appkit_assistant-0.7.0/src/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-0.7.0/src/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-0.7.0/src/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-0.7.0/src/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,
+)