appkit-assistant 0.16.2__tar.gz → 0.17.0__tar.gz

{appkit_assistant-0.16.2 → appkit_assistant-0.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: appkit-assistant
-Version: 0.16.2
+Version: 0.17.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
@@ -16,9 +16,12 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: User Interfaces
 Requires-Python: >=3.13
+Requires-Dist: anthropic>=0.40.0
 Requires-Dist: appkit-commons
 Requires-Dist: appkit-mantine
 Requires-Dist: appkit-ui
+Requires-Dist: google-genai>=1.52.0
+Requires-Dist: mcp>=1.0.0
 Requires-Dist: openai>=2.3.0
 Requires-Dist: reflex>=0.8.22
 Description-Content-Type: text/markdown

{appkit_assistant-0.16.2 → appkit_assistant-0.17.0}/pyproject.toml

@@ -1,13 +1,16 @@
 [project]
 dependencies = [
+    "anthropic>=0.40.0",
     "appkit-commons",
     "appkit-mantine",
     "appkit-ui",
+    "google-genai>=1.52.0",
+    "mcp>=1.0.0",
     "openai>=2.3.0",
     "reflex>=0.8.22",
 ]
 name = "appkit-assistant"
-version = "0.16.2"
+version = "0.17.0"
 description = "Add your description here"
 readme = "README.md"
 authors = [{ name = "Jens Rehpöhler" }]

appkit_assistant-0.17.0/src/appkit_assistant/backend/file_manager.py

@@ -0,0 +1,117 @@
+"""File management utilities for assistant uploads.
+
+This module provides utilities for managing uploaded files in user-specific
+directories. Files are stored temporarily and cleaned up after processing.
+"""
+
+import logging
+import shutil
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+# Base directory for uploaded files (relative to project root)
+UPLOAD_BASE_DIR = Path("uploaded_files")
+
+
+def get_user_upload_directory(user_id: str) -> Path:
+    """Get the upload directory for a specific user.
+
+    Creates the directory if it doesn't exist.
+
+    Args:
+        user_id: The user's unique identifier.
+
+    Returns:
+        Path to the user's upload directory.
+    """
+    user_dir = UPLOAD_BASE_DIR / user_id
+    user_dir.mkdir(parents=True, exist_ok=True)
+    logger.debug("User upload dir: %s", user_dir)
+    return user_dir
+
+
+def _make_unique_filename(target_path: Path) -> Path:
+    """Generate a unique filename if target already exists.
+
+    Appends _1, _2, etc. before the extension until a unique name is found.
+
+    Args:
+        target_path: The desired file path.
+
+    Returns:
+        A unique file path that doesn't exist yet.
+    """
+    if not target_path.exists():
+        return target_path
+
+    stem = target_path.stem
+    suffix = target_path.suffix
+    parent = target_path.parent
+    counter = 1
+
+    while True:
+        new_name = f"{stem}_{counter}{suffix}"
+        new_path = parent / new_name
+        if not new_path.exists():
+            return new_path
+        counter += 1
+
+
+def move_to_user_directory(temp_path: str, user_id: str) -> str:
+    """Move a file from temporary location to user's upload directory.
+
+    Args:
+        temp_path: Path to the temporary file (from browser upload).
+        user_id: The user's unique identifier.
+
+    Returns:
+        Absolute path to the file in the user's directory.
+
+    Raises:
+        FileNotFoundError: If the source file doesn't exist.
+    """
+    source = Path(temp_path)
+    if not source.exists():
+        raise FileNotFoundError(f"Source file not found: {temp_path}")
+
+    user_dir = get_user_upload_directory(user_id)
+    target = user_dir / source.name
+    target = _make_unique_filename(target)
+
+    shutil.move(str(source), str(target))
+    logger.info("Moved file to user directory: %s → %s", temp_path, target)
+
+    return str(target.absolute())
+
+
+def cleanup_uploaded_files(file_paths: list[str]) -> None:
+    """Delete uploaded files from disk.
+
+    Args:
+        file_paths: List of absolute file paths to delete.
+    """
+    deleted_count = 0
+    for file_path in file_paths:
+        try:
+            Path(file_path).unlink(missing_ok=True)
+            deleted_count += 1
+        except OSError as e:
+            logger.warning("Failed to delete file %s: %s", file_path, e)
+
+    logger.debug("Cleaned up %d uploaded files", deleted_count)
+
+
+def get_file_size(file_path: str) -> int:
+    """Get the size of a file in bytes.
+
+    Args:
+        file_path: Path to the file.
+
+    Returns:
+        File size in bytes, or 0 if file doesn't exist.
+    """
+    try:
+        return Path(file_path).stat().st_size
+    except OSError:
+        return 0

{appkit_assistant-0.16.2 → appkit_assistant-0.17.0}/src/appkit_assistant/backend/models.py

@@ -86,6 +86,7 @@ class Message(BaseModel):
     editable: bool = False
     type: MessageType
     done: bool = False
+    attachments: list[str] = []  # List of filenames for display
 
 
 class ThinkingType(StrEnum):
@@ -131,6 +132,14 @@ class Suggestion(BaseModel):
     icon: str = ""
 
 
+class UploadedFile(BaseModel):
+    """Model for tracking uploaded files in the composer."""
+
+    filename: str
+    file_path: str
+    size: int = 0
+
+
 class ThreadModel(BaseModel):
     thread_id: str
     title: str = ""

appkit_assistant-0.17.0/src/appkit_assistant/backend/processors/claude_base.py

@@ -0,0 +1,178 @@
+"""
+Claude base processor for generating AI responses using Anthropic's Claude API.
+"""
+
+import logging
+from abc import ABC, abstractmethod
+from collections.abc import AsyncGenerator
+from pathlib import Path
+from typing import Any, Final
+
+from anthropic import AsyncAnthropic
+
+from appkit_assistant.backend.models import (
+    AIModel,
+    Chunk,
+    MCPServer,
+    Message,
+)
+from appkit_assistant.backend.processor import Processor
+
+logger = logging.getLogger(__name__)
+
+CLAUDE_HAIKU_4_5: Final = AIModel(
+    id="claude-haiku-4.5",
+    text="Claude 4.5 Haiku",
+    icon="anthropic",
+    model="claude-haiku-4-5",
+    stream=True,
+    supports_attachments=False,
+    supports_tools=True,
+    temperature=1.0,
+)
+
+CLAUDE_SONNET_4_5: Final = AIModel(
+    id="claude-sonnet-4.5",
+    text="Claude 4.5 Sonnet",
+    icon="anthropic",
+    model="claude-sonnet-4-5",
+    stream=True,
+    supports_attachments=False,
+    supports_tools=True,
+    temperature=1.0,
+)
+
+
+class BaseClaudeProcessor(Processor, ABC):
+    """Base class for Claude processors with common initialization and utilities."""
+
+    # Extended thinking budget (fixed at 10k tokens)
+    THINKING_BUDGET_TOKENS: Final[int] = 10000
+
+    # Max file size (5MB)
+    MAX_FILE_SIZE: Final[int] = 5 * 1024 * 1024
+
+    # Allowed file extensions
+    ALLOWED_EXTENSIONS: Final[set[str]] = {
+        "pdf",
+        "png",
+        "jpg",
+        "jpeg",
+        "xlsx",
+        "csv",
+        "docx",
+        "pptx",
+        "md",
+    }
+
+    # Image extensions (for determining content type)
+    IMAGE_EXTENSIONS: Final[set[str]] = {"png", "jpg", "jpeg", "gif", "webp"}
+
+    def __init__(
+        self,
+        models: dict[str, AIModel],
+        api_key: str | None = None,
+        base_url: str | None = None,
+    ) -> None:
+        """Initialize the base Claude processor.
+
+        Args:
+            models: Dictionary of supported AI models
+            api_key: API key for Anthropic Claude API (or Azure API key)
+            base_url: Base URL for Azure-hosted Claude (optional)
+        """
+        self.api_key = api_key
+        self.base_url = base_url
+        self.models = models
+        self.client: AsyncAnthropic | None = None
+
+        if self.api_key:
+            if self.base_url:
+                # Azure-hosted Claude
+                self.client = AsyncAnthropic(
+                    api_key=self.api_key,
+                    base_url=self.base_url,
+                )
+            else:
+                # Direct Anthropic API
+                self.client = AsyncAnthropic(api_key=self.api_key)
+        else:
+            logger.warning("No Claude API key found. Processor will not work.")
+
+    @abstractmethod
+    async def process(
+        self,
+        messages: list[Message],
+        model_id: str,
+        files: list[str] | None = None,
+        mcp_servers: list[MCPServer] | None = None,
+        payload: dict[str, Any] | None = None,
+        user_id: int | None = None,
+    ) -> AsyncGenerator[Chunk, None]:
+        """Process messages and generate AI response chunks."""
+
+    def get_supported_models(self) -> dict[str, AIModel]:
+        """Return supported models if API key is available."""
+        return self.models if self.api_key else {}
+
+    def _get_file_extension(self, file_path: str) -> str:
+        """Extract file extension from path."""
+        return file_path.rsplit(".", 1)[-1].lower() if "." in file_path else ""
+
+    def _is_image_file(self, file_path: str) -> bool:
+        """Check if file is an image based on extension."""
+        ext = self._get_file_extension(file_path)
+        return ext in self.IMAGE_EXTENSIONS
+
+    def _get_media_type(self, file_path: str) -> str:
+        """Get MIME type for a file based on extension."""
+        ext = self._get_file_extension(file_path)
+        media_types = {
+            "pdf": "application/pdf",
+            "png": "image/png",
+            "jpg": "image/jpeg",
+            "jpeg": "image/jpeg",
+            "gif": "image/gif",
+            "webp": "image/webp",
+            "xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+            "csv": "text/csv",
+            "docx": (
+                "application/vnd.openxmlformats-officedocument.wordprocessingml"
+                ".document"
+            ),
+            "pptx": (
+                "application/vnd.openxmlformats-officedocument.presentationml"
+                ".presentation"
+            ),
+            "md": "text/markdown",
+            "txt": "text/plain",
+        }
+        return media_types.get(ext, "application/octet-stream")
+
+    def _validate_file(self, file_path: str) -> tuple[bool, str]:
+        """Validate file for upload.
+
+        Args:
+            file_path: Path to the file
+
+        Returns:
+            Tuple of (is_valid, error_message)
+        """
+        path = Path(file_path)
+
+        # Check if file exists
+        if not path.exists():
+            return False, f"File not found: {file_path}"
+
+        # Check extension
+        ext = self._get_file_extension(file_path)
+        if ext not in self.ALLOWED_EXTENSIONS:
+            return False, f"Unsupported file type: {ext}"
+
+        # Check file size
+        file_size = path.stat().st_size
+        if file_size > self.MAX_FILE_SIZE:
+            size_mb = file_size / (1024 * 1024)
+            return False, f"File too large: {size_mb:.1f}MB (max 5MB)"
+
+        return True, ""