appkit-assistant 0.7.1__py3-none-any.whl

appkit_assistant/backend/processors/lorem_ipsum_processor.py

@@ -0,0 +1,123 @@
+"""
+Lorem Ipsum processor for generating random text responses.
+"""
+
+import asyncio
+import logging
+import random
+from collections.abc import AsyncGenerator
+
+from appkit_assistant.backend.models import (
+    AIModel,
+    Chunk,
+    ChunkType,
+    MCPServer,
+    Message,
+)
+from appkit_assistant.backend.processor import Processor
+
+logger = logging.getLogger(__name__)
+
+# List of Lorem Ipsum paragraphs for random selection
+LOREM_PARAGRAPHS = [
+    "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.",  # noqa: E501
+    "Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.",  # noqa: E501
+    "Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.",  # noqa: E501
+    "Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.",  # noqa: E501
+    "Integer posuere erat a ante venenatis dapibus posuere velit aliquet.",
+    "Cras mattis consectetur purus sit amet fermentum. Nullam quis risus eget urna mollis ornare vel eu leo.",  # noqa: E501
+    "Donec sed odio dui. Maecenas faucibus mollis interdum. Cras justo odio, dapibus ac facilisis in, egestas eget quam.",  # noqa: E501
+    "Vestibulum id ligula porta felis euismod semper. Lorem ipsum dolor sit amet, consectetur adipiscing elit.",  # noqa: E501
+]
+
+# Models supported by this processor as a dictionary with model ID as the key
+LOREM_MODELS = {
+    "lorem-short": AIModel(
+        id="lorem-short",
+        text="Lorem Ipsum",
+        icon="codesandbox",
+        model="lorem-short",
+        stream=True,
+    )
+}
+
+
+class LoremIpsumProcessor(Processor):
+    """Processor that generates Lorem Ipsum text responses."""
+
+    def __init__(self, models: dict[str, AIModel] = LOREM_MODELS) -> None:
+        """Initialize the Lorem Ipsum processor."""
+        self.models = models
+        logger.debug("Lorem Ipsum processor initialized")
+
+    async def process(
+        self,
+        messages: list[Message],  # noqa: ARG002
+        model_id: str,
+        files: list[str] | None = None,  # noqa: ARG002
+        mcp_servers: list[MCPServer] | None = None,  # noqa: ARG002
+    ) -> AsyncGenerator[Chunk, None]:
+        """
+        Generate a Lorem Ipsum response of varying lengths based on the model_id.
+
+        Args:
+            messages: List of messages (ignored for this processor).
+            model_id: The model ID (determines response length).
+            files: Optional list of files (ignored for this processor).
+            mcp_servers: Optional list of MCP servers (ignored for this processor).
+
+        Returns:
+            An async generator that yields Chunk objects with text content.
+        """
+        if model_id not in self.models:
+            raise ValueError(f"Model {model_id} not supported by Lorem Ipsum processor")
+
+        # Simulate thinking process
+        yield Chunk(
+            type=ChunkType.THINKING,
+            text="I think i need to generate Lorem Ipsum content...",
+            chunk_metadata={"source": "lorem_ipsum", "model": model_id},
+        )
+        await asyncio.sleep(0.5)
+
+        num_paragraphs = random.randint(4, 8)  # noqa: S311
+        for i in range(num_paragraphs):
+            paragraph = random.choice(LOREM_PARAGRAPHS)  # noqa: S311
+            words = paragraph.split()
+            for word in words:
+                content = word + " "
+                await asyncio.sleep(0.01)
+                yield Chunk(
+                    type=ChunkType.TEXT,
+                    text=content,
+                    chunk_metadata={
+                        "source": "lorem_ipsum",
+                        "paragraph": str(i + 1),
+                        "total_paragraphs": str(num_paragraphs),
+                    },
+                )
+
+            if i < num_paragraphs - 1:
+                yield Chunk(
+                    type=ChunkType.TEXT,
+                    text="\n\n",
+                    chunk_metadata={
+                        "source": "lorem_ipsum",
+                        "type": "paragraph_separator",
+                    },
+                )
+
+        yield Chunk(
+            type=ChunkType.THINKING,
+            text="So, generated enough Lorem Ipsum for you!",
+            chunk_metadata={"source": "lorem_ipsum", "model": model_id},
+        )
+
+    def get_supported_models(self) -> dict[str, AIModel]:
+        """
+        Get dictionary of supported models.
+
+        Returns:
+            Dictionary mapping model IDs to AIModel objects.
+        """
+        return self.models

appkit_assistant/backend/processors/openai_base.py

@@ -0,0 +1,73 @@
+"""
+OpenAI processor for generating AI responses using OpenAI's API.
+"""
+
+import logging
+from abc import ABC, abstractmethod
+from collections.abc import AsyncGenerator
+from typing import Any
+
+from openai import AsyncAzureOpenAI, AsyncOpenAI
+
+from appkit_assistant.backend.models import (
+    AIModel,
+    Chunk,
+    MCPServer,
+    Message,
+)
+from appkit_assistant.backend.processor import Processor
+
+logger = logging.getLogger(__name__)
+
+
+class BaseOpenAIProcessor(Processor, ABC):
+    """Base class for OpenAI processors with common initialization and utilities."""
+
+    def __init__(
+        self,
+        models: dict[str, AIModel],
+        api_key: str | None = None,
+        base_url: str | None = None,
+        is_azure: bool = False,
+    ) -> None:
+        """Initialize the base OpenAI processor.
+
+        Args:
+            models: Dictionary of supported AI models
+            api_key: API key for OpenAI/Azure OpenAI
+            base_url: Base URL for the API
+            is_azure: Whether to use Azure OpenAI client
+        """
+        self.api_key = api_key
+        self.base_url = base_url
+        self.models = models
+        self.is_azure = is_azure
+        self.client = None
+
+        if self.api_key and self.base_url and is_azure:
+            self.client = AsyncAzureOpenAI(
+                api_key=self.api_key,
+                azure_endpoint=self.base_url,
+                api_version="2025-04-01-preview",
+            )
+        elif self.api_key and self.base_url:
+            self.client = AsyncOpenAI(api_key=self.api_key, base_url=self.base_url)
+        elif self.api_key:
+            self.client = AsyncOpenAI(api_key=self.api_key)
+        else:
+            logger.warning("No 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,
+    ) -> 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 {}

appkit_assistant/backend/processors/openai_chat_completion_processor.py

@@ -0,0 +1,117 @@
+import logging
+from collections.abc import AsyncGenerator
+from typing import Any
+
+from openai import AsyncStream
+from openai.types.chat import ChatCompletionMessageParam
+
+from appkit_assistant.backend.models import (
+    Chunk,
+    ChunkType,
+    MCPServer,
+    Message,
+    MessageType,
+)
+from appkit_assistant.backend.processors.openai_base import BaseOpenAIProcessor
+
+logger = logging.getLogger(__name__)
+
+
+class OpenAIChatCompletionsProcessor(BaseOpenAIProcessor):
+    """Processor that generates responses using OpenAI's Chat Completions API."""
+
+    async def process(
+        self,
+        messages: list[Message],
+        model_id: str,
+        files: list[str] | None = None,  # noqa: ARG002
+        mcp_servers: list[MCPServer] | None = None,
+        payload: dict[str, Any] | None = None,
+    ) -> AsyncGenerator[Chunk, None]:
+        """Process messages using the Chat Completions API.
+
+        Args:
+            messages: List of messages to process
+            model_id: ID of the model to use
+            files: File attachments (not used in chat completions)
+            mcp_servers: MCP servers (will log warning if provided)
+            payload: Additional payload parameters
+        """
+        if not self.client:
+            raise ValueError("OpenAI Client not initialized.")
+
+        if model_id not in self.models:
+            raise ValueError(f"Model {model_id} not supported by OpenAI processor")
+
+        if mcp_servers:
+            logger.warning(
+                "MCP servers provided to ChatCompletionsProcessor but not supported. "
+                "Use OpenAIResponsesProcessor for MCP functionality."
+            )
+
+        model = self.models[model_id]
+
+        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=payload,
+            )
+
+            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 self._create_chunk(content, model.model, stream=True)
+            else:
+                content = session.choices[0].message.content
+                if content:
+                    yield self._create_chunk(content, model.model)
+        except Exception as e:
+            raise e
+
+    def _create_chunk(self, content: str, model: str, stream: bool = False) -> Chunk:
+        return Chunk(
+            type=ChunkType.TEXT,
+            text=content,
+            chunk_metadata={
+                "source": "chat_completions",
+                "streaming": str(stream),
+                "model": model,
+            },
+        )
+
+    def _convert_messages_to_openai_format(
+        self, messages: list[Message]
+    ) -> list[ChatCompletionMessageParam]:
+        """Convert internal messages to OpenAI chat completion format.
+
+        Notes:
+        - OpenAI Chat Completions requires that after any system messages,
+          user/tool messages must alternate with assistant messages. To
+          ensure this, merge consecutive user (human) or assistant messages
+          into a single message by concatenating their text with a blank
+          line separator.
+        """
+        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:
+                # Merge consecutive user/assistant messages
+                formatted[-1]["content"] = formatted[-1]["content"] + "\n\n" + msg.text
+            else:
+                formatted.append({"role": role, "content": msg.text})
+
+        return formatted