appkit-assistant 0.17.3__py3-none-any.whl → 1.0.1__py3-none-any.whl

appkit_assistant/backend/processors/perplexity_processor.py

@@ -1,76 +1,25 @@
 import asyncio
-import enum
 import logging
 import os
 from collections.abc import AsyncGenerator
 from typing import Any
 
-from appkit_assistant.backend.models import AIModel, Chunk, MCPServer, Message
-from appkit_assistant.backend.processors.openai_chat_completion_processor import (
-    OpenAIChatCompletionsProcessor,
-)
-
-logger = logging.getLogger(__name__)
-
-
-class ContextSize(enum.StrEnum):
-    """Enum for context size options."""
-
-    LOW = "low"
-    MEDIUM = "medium"
-    HIGH = "high"
-
-
-class PerplexityAIModel(AIModel):
-    """AI model for Perplexity API."""
+from openai import AsyncStream
 
-    search_context_size: ContextSize = ContextSize.MEDIUM
-    search_domain_filter: list[str] = []
-
-
-SONAR = PerplexityAIModel(
-    id="sonar",
-    text="Perplexity Sonar",
-    icon="perplexity",
-    model="sonar",
-    stream=True,
+from appkit_assistant.backend.database.models import (
+    MCPServer,
 )
-
-SONAR_PRO = PerplexityAIModel(
-    id="sonar-pro",
-    text="Perplexity Sonar Pro",
-    icon="perplexity",
-    model="sonar-pro",
-    stream=True,
-    keywords=["sonar", "perplexity"],
-)
-
-SONAR_DEEP_RESEARCH = PerplexityAIModel(
-    id="sonar-deep-research",
-    text="Perplexity Deep Research",
-    icon="perplexity",
-    model="sonar-deep-research",
-    search_context_size=ContextSize.HIGH,
-    stream=True,
-    keywords=["reasoning", "deep", "research", "perplexity"],
+from appkit_assistant.backend.models.perplexity import PerplexityAIModel
+from appkit_assistant.backend.processors.openai_chat_completion_processor import (
+    OpenAIChatCompletionsProcessor,
 )
-
-SONAR_REASONING = PerplexityAIModel(
-    id="sonar-reasoning",
-    text="Perplexity Reasoning",
-    icon="perplexity",
-    model="sonar-reasoning",
-    search_context_size=ContextSize.HIGH,
-    stream=True,
-    keywords=["reasoning", "perplexity"],
+from appkit_assistant.backend.schemas import (
+    Chunk,
+    Message,
 )
+from appkit_assistant.backend.services.chunk_factory import ChunkFactory
 
-ALL_MODELS = {
-    SONAR.id: SONAR,
-    SONAR_PRO.id: SONAR_PRO,
-    SONAR_DEEP_RESEARCH.id: SONAR_DEEP_RESEARCH,
-    SONAR_REASONING.id: SONAR_REASONING,
-}
+logger = logging.getLogger(__name__)
 
 
 class PerplexityProcessor(OpenAIChatCompletionsProcessor):
@@ -83,24 +32,79 @@ class PerplexityProcessor(OpenAIChatCompletionsProcessor):
     ) -> None:
         self.base_url = "https://api.perplexity.ai"
         super().__init__(api_key=api_key, base_url=self.base_url, models=models)
+        self._chunk_factory = ChunkFactory(processor_name="perplexity")
 
     async def process(
         self,
         messages: list[Message],
         model_id: str,
-        files: list[str] | None = None,
-        mcp_servers: list[MCPServer] | None = None,  # noqa: ARG002
+        files: list[str] | None = None,  # noqa: ARG002
+        mcp_servers: list[MCPServer] | None = None,
         payload: dict[str, Any] | None = None,
         cancellation_token: asyncio.Event | None = None,
-        **kwargs: Any,
+        **kwargs: Any,  # noqa: ARG002
     ) -> AsyncGenerator[Chunk, None]:
+        """Process messages using Perplexity API with citation support.
+
+        Args:
+            messages: List of messages to process.
+            model_id: ID of the model to use.
+            files: File attachments (not used in Perplexity).
+            mcp_servers: MCP servers (not supported, will log warning).
+            payload: Additional payload parameters.
+            cancellation_token: Optional event to signal cancellation.
+            **kwargs: Additional arguments.
+        """
+        if not self.client:
+            raise ValueError("Perplexity Client not initialized.")
+
         if model_id not in self.models:
             logger.error("Model %s not supported by Perplexity processor", model_id)
             raise ValueError(f"Model {model_id} not supported by Perplexity processor")
 
-        model = self.models[model_id]
+        if mcp_servers:
+            logger.warning(
+                "MCP servers provided to PerplexityProcessor but not supported."
+            )
 
-        # Create Perplexity-specific payload
+        model = self.models[model_id]
+        perplexity_payload = self._build_perplexity_payload(model, payload)
+
+        try:
+            chat_messages = self._convert_messages_to_openai_format(messages)
+            session = await self.client.chat.completions.create(
+                model=model.model,
+                messages=chat_messages[:-1],
+                stream=model.stream,
+                temperature=model.temperature,
+                extra_body=perplexity_payload,
+            )
+
+            if isinstance(session, AsyncStream):
+                async for chunk in self._process_streaming_response(
+                    session, model, cancellation_token
+                ):
+                    yield chunk
+            else:
+                async for chunk in self._process_non_streaming_response(session, model):
+                    yield chunk
+
+        except Exception as e:
+            logger.error("Error in Perplexity processor: %s", e)
+            raise
+
+    def _build_perplexity_payload(
+        self, model: PerplexityAIModel, payload: dict[str, Any] | None
+    ) -> dict[str, Any]:
+        """Build the Perplexity-specific payload.
+
+        Args:
+            model: The Perplexity AI model configuration.
+            payload: Additional payload parameters to merge.
+
+        Returns:
+            Combined payload dictionary for the API request.
+        """
         perplexity_payload = {
             "search_domain_filter": model.search_domain_filter,
             "return_images": True,
@@ -109,18 +113,91 @@ class PerplexityProcessor(OpenAIChatCompletionsProcessor):
                 "search_context_size": model.search_context_size,
             },
         }
-
-        # Merge with any additional payload
         if payload:
             perplexity_payload.update(payload)
+        return perplexity_payload
+
+    async def _process_streaming_response(
+        self,
+        session: AsyncStream[Any],
+        model: PerplexityAIModel,
+        cancellation_token: asyncio.Event | None,
+    ) -> AsyncGenerator[Chunk, None]:
+        """Process a streaming response from Perplexity API.
+
+        Args:
+            session: The async stream from the API.
+            model: The model configuration.
+            cancellation_token: Optional cancellation event.
+
+        Yields:
+            Chunk objects with text content and citations.
+        """
+        citations: list[str] = []
+
+        async for event in session:
+            if cancellation_token and cancellation_token.is_set():
+                logger.info("Processing cancelled by user")
+                break
+
+            # Extract citations from streaming response if available
+            if hasattr(event, "citations") and event.citations:
+                citations = event.citations
+
+            if event.choices and event.choices[0].delta:
+                content = event.choices[0].delta.content
+                if content:
+                    yield self._create_chunk(
+                        content, model.model, stream=True, message_id=event.id
+                    )
+
+        # After streaming completes, yield citation annotations
+        async for chunk in self._yield_citations(citations):
+            yield chunk
+
+    async def _process_non_streaming_response(
+        self, session: Any, model: PerplexityAIModel
+    ) -> AsyncGenerator[Chunk, None]:
+        """Process a non-streaming response from Perplexity API.
+
+        Args:
+            session: The response object from the API.
+            model: The model configuration.
+
+        Yields:
+            Chunk objects with text content and citations.
+        """
+        content = session.choices[0].message.content
+        citations: list[str] = []
+
+        if hasattr(session, "citations") and session.citations:
+            citations = session.citations
+
+        if content:
+            yield self._create_chunk(content, model.model, message_id=session.id)
+
+        async for chunk in self._yield_citations(citations):
+            yield chunk
+
+    async def _yield_citations(
+        self, citations: list[str]
+    ) -> AsyncGenerator[Chunk, None]:
+        """Yield annotation chunks for citations.
+
+        Args:
+            citations: List of citation URLs from Perplexity API.
+
+        Yields:
+            Chunk objects with citation annotations.
+        """
+        if not citations:
+            return
+
+        logger.debug("Processing %d citations from Perplexity", len(citations))
 
-        async for response in super().process(
-            messages=messages,
-            model_id=model_id,
-            files=files,
-            mcp_servers=None,
-            payload=perplexity_payload,
-            cancellation_token=cancellation_token,
-            **kwargs,
-        ):
-            yield response
+        # Yield individual ANNOTATION chunks for citations display
+        for url in citations:
+            yield self._chunk_factory.annotation(
+                text=url,
+                annotation_data={"url": url, "source": "perplexity"},
+            )

appkit_assistant/backend/{processor.py → processors/processor_base.py}

@@ -7,7 +7,12 @@ import asyncio
 import logging
 from collections.abc import AsyncGenerator
 
-from appkit_assistant.backend.models import AIModel, Chunk, MCPServer, Message
+from appkit_assistant.backend.database.models import MCPServer
+from appkit_assistant.backend.schemas import (
+    AIModel,
+    Chunk,
+    Message,
+)
 from appkit_commons.configuration.configuration import ReflexConfig
 from appkit_commons.registry import service_registry
 
@@ -31,7 +36,7 @@ def mcp_oauth_redirect_uri() -> str:
     return f"http://localhost:8080{MCP_OAUTH_CALLBACK_PATH}"
 
 
-class Processor(abc.ABC):
+class ProcessorBase(abc.ABC):
     """Base processor interface for AI processing services."""
 
     @abc.abstractmethod

appkit_assistant/backend/processors/streaming_base.py

@@ -0,0 +1,188 @@
+"""Streaming Processor Base class.
+
+Provides a unified base class for all streaming AI processors with:
+- Standardized dict-based event dispatch
+- Cancellation token handling
+- Common state management
+- Composed service dependencies
+"""
+
+import asyncio
+import logging
+from abc import ABC, abstractmethod
+from collections.abc import AsyncGenerator
+from typing import Any
+
+from appkit_assistant.backend.database.models import (
+    MCPServer,
+)
+from appkit_assistant.backend.processors.processor_base import ProcessorBase
+from appkit_assistant.backend.schemas import (
+    AIModel,
+    Chunk,
+    ChunkType,
+    Message,
+)
+from appkit_assistant.backend.services.auth_error_detector import AuthErrorDetector
+from appkit_assistant.backend.services.chunk_factory import ChunkFactory
+
+logger = logging.getLogger(__name__)
+
+
+class StreamingProcessorBase(ProcessorBase, ABC):
+    """Base class for streaming AI processors.
+
+    Provides common functionality for:
+    - Event dispatch via dict-based handlers
+    - Cancellation token checking
+    - Common state tracking (reasoning sessions)
+    - Chunk creation via ChunkFactory
+    - Error detection via AuthErrorDetector
+
+    Note: For user ID tracking and MCP capabilities, combine with MCPCapabilities mixin.
+
+    Subclasses must implement:
+    - _get_event_handlers(): Return dict mapping event types to handlers
+    - get_supported_models(): Return supported models
+    """
+
+    def __init__(
+        self,
+        models: dict[str, AIModel],
+        processor_name: str,
+    ) -> None:
+        """Initialize the streaming processor base.
+
+        Args:
+            models: Dictionary of supported AI models
+            processor_name: Name for chunk metadata (e.g., "claude_responses")
+        """
+        self.models = models
+        self._chunk_factory = ChunkFactory(processor_name)
+        self._auth_detector = AuthErrorDetector()
+
+        # Common streaming state
+        self._current_reasoning_session: str | None = None
+
+    @property
+    def chunk_factory(self) -> ChunkFactory:
+        """Get the chunk factory instance."""
+        return self._chunk_factory
+
+    @property
+    def auth_detector(self) -> AuthErrorDetector:
+        """Get the auth error detector instance."""
+        return self._auth_detector
+
+    @property
+    def current_reasoning_session(self) -> str | None:
+        """Get the current reasoning session ID."""
+        return self._current_reasoning_session
+
+    @current_reasoning_session.setter
+    def current_reasoning_session(self, value: str | None) -> None:
+        """Set the current reasoning session ID."""
+        self._current_reasoning_session = value
+
+    def get_supported_models(self) -> dict[str, AIModel]:
+        """Return supported models."""
+        return self.models
+
+    @abstractmethod
+    def _get_event_handlers(self) -> dict[str, Any]:
+        """Get the event handler mapping.
+
+        Returns:
+            Dict mapping event type strings to handler methods.
+            Handler methods should accept the event and return Chunk | None.
+        """
+
+    def _handle_event(self, event: Any) -> Chunk | None:
+        """Handle a streaming event using dict-based dispatch.
+
+        Args:
+            event: The event object from the API stream
+
+        Returns:
+            A Chunk if the event produced content, None otherwise
+        """
+        event_type = getattr(event, "type", None)
+        if not event_type:
+            return None
+
+        handlers = self._get_event_handlers()
+        handler = handlers.get(event_type)
+
+        if handler:
+            return handler(event)
+
+        logger.debug("Unhandled event type: %s", event_type)
+        return None
+
+    async def _process_stream_with_cancellation(
+        self,
+        stream: Any,
+        cancellation_token: asyncio.Event | None = None,
+    ) -> AsyncGenerator[Chunk, None]:
+        """Process a stream with cancellation support.
+
+        Args:
+            stream: Async iterable stream of events
+            cancellation_token: Optional event to signal cancellation
+
+        Yields:
+            Chunk objects from handled events
+        """
+        try:
+            async for event in stream:
+                if cancellation_token and cancellation_token.is_set():
+                    logger.info("Processing cancelled by user")
+                    break
+
+                chunk = self._handle_event(event)
+                if chunk:
+                    yield chunk
+        except Exception as e:
+            error_msg = str(e)
+            logger.error("Error during stream processing: %s", error_msg)
+
+            # Only yield error chunk if NOT an auth error
+            if not self._auth_detector.is_auth_error(error_msg):
+                yield self._chunk_factory.error(
+                    f"Ein Fehler ist aufgetreten: {error_msg}",
+                    error_type=type(e).__name__,
+                )
+
+    def _create_chunk(
+        self,
+        chunk_type: ChunkType,
+        content: str,
+        extra_metadata: dict[str, Any] | None = None,
+    ) -> Chunk:
+        """Create a chunk using the factory (convenience method).
+
+        Args:
+            chunk_type: The type of chunk
+            content: The text content
+            extra_metadata: Additional metadata
+
+        Returns:
+            A Chunk instance
+        """
+        return self._chunk_factory.create(chunk_type, content, extra_metadata)
+
+    @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,
+        cancellation_token: asyncio.Event | None = None,
+    ) -> AsyncGenerator[Chunk, None]:
+        """Process messages and generate response chunks.
+
+        Must be implemented by subclasses to handle vendor-specific API calls.
+        """

appkit_assistant/backend/schemas.py

@@ -0,0 +1,138 @@
+import uuid
+from enum import StrEnum
+
+from pydantic import BaseModel
+from sqlmodel import Field
+
+
+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
+    PROCESSING = "processing"  # file processing status
+    COMPLETION = "completion"  # when response generation is complete
+    AUTH_REQUIRED = "auth_required"  # user needs to authenticate (MCP)
+    ERROR = "error"  # when an error occurs
+    LIFECYCLE = "lifecycle"
+
+
+class Chunk(BaseModel):
+    """Model for text chunks."""
+
+    type: ChunkType
+    text: str
+    chunk_metadata: dict[str, str | None] = {}
+
+
+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):
+    id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    text: str
+    original_text: str | None = None  # To store original text if edited
+    editable: bool = False
+    type: MessageType
+    done: bool = False
+    attachments: list[str] = []  # List of filenames for display
+    annotations: list[str] = []  # List of file citations/annotations
+
+
+class ThinkingType(StrEnum):
+    REASONING = "reasoning"
+    TOOL_CALL = "tool_call"
+    PROCESSING = "processing"
+
+
+class ThinkingStatus(StrEnum):
+    IN_PROGRESS = "in_progress"
+    COMPLETED = "completed"
+    ERROR = "error"
+
+
+class Thinking(BaseModel):
+    type: ThinkingType
+    id: str  # reasoning_session_id or tool_id
+    text: str
+    status: ThinkingStatus = ThinkingStatus.IN_PROGRESS
+    tool_name: str | None = None
+    parameters: str | None = None
+    result: str | None = None
+    error: str | None = None
+
+
+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
+    supports_search: bool = False
+    keywords: list[str] = []
+    disabled: bool = False
+    requires_role: str | None = None
+
+
+class Suggestion(BaseModel):
+    prompt: str
+    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 = ""
+    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"