appkit-assistant 0.15.1__tar.gz → 0.15.3__tar.gz

{appkit_assistant-0.15.1 → appkit_assistant-0.15.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: appkit-assistant
-Version: 0.15.1
+Version: 0.15.3
 Summary: Add your description here
 Project-URL: Homepage, https://github.com/jenreh/appkit
 Project-URL: Documentation, https://github.com/jenreh/appkit/tree/main/docs

{appkit_assistant-0.15.1 → appkit_assistant-0.15.3}/pyproject.toml

@@ -7,7 +7,7 @@ dependencies = [
     "reflex>=0.8.22",
 ]
 name = "appkit-assistant"
-version = "0.15.1"
+version = "0.15.3"
 description = "Add your description here"
 readme = "README.md"
 authors = [{ name = "Jens Rehpöhler" }]

{appkit_assistant-0.15.1 → appkit_assistant-0.15.3}/src/appkit_assistant/backend/models.py

@@ -88,6 +88,28 @@ class Message(BaseModel):
     done: bool = False
 
 
+class ThinkingType(StrEnum):
+    REASONING = "reasoning"
+    TOOL_CALL = "tool_call"
+
+
+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

{appkit_assistant-0.15.1 → appkit_assistant-0.15.3}/src/appkit_assistant/backend/processors/openai_responses_processor.py

@@ -84,8 +84,22 @@ class OpenAIResponsesProcessor(BaseOpenAIProcessor):
                             },
                         )
             except Exception as e:
-                logger.error("Error during response processing: %s", e)
-                # Continue to yield auth chunks if any
+                error_msg = str(e)
+                logger.error("Error during response processing: %s", error_msg)
+                # Only yield error chunk if NOT an auth error
+                # and no auth servers are pending (they'll show auth card instead)
+                is_auth_related = (
+                    self._is_auth_error(error_msg) or self._pending_auth_servers
+                )
+                if not is_auth_related:
+                    yield Chunk(
+                        type=ChunkType.ERROR,
+                        text=f"Ein Fehler ist aufgetreten: {error_msg}",
+                        chunk_metadata={
+                            "source": "responses_api",
+                            "error_type": type(e).__name__,
+                        },
+                    )
 
             # After processing (or on error), yield any pending auth requirements
             logger.debug(

appkit_assistant-0.15.3/src/appkit_assistant/backend/services/thread_service.py

@@ -0,0 +1,134 @@
+import logging
+import uuid
+
+from appkit_assistant.backend.model_manager import ModelManager
+from appkit_assistant.backend.models import (
+    AssistantThread,
+    Message,
+    ThreadModel,
+    ThreadStatus,
+)
+from appkit_assistant.backend.repositories import thread_repo
+from appkit_commons.database.session import get_asyncdb_session
+
+logger = logging.getLogger(__name__)
+
+
+class ThreadService:
+    """
+    Service for managing assistant threads.
+    Handles creation, loading, and persistence of threads.
+    """
+
+    def __init__(self):
+        self.model_manager = ModelManager()
+
+    def create_new_thread(
+        self, current_model: str, user_roles: list[str] | None = None
+    ) -> ThreadModel:
+        """Create a new ephemeral thread model (not persisted)."""
+        if user_roles is None:
+            user_roles = []
+
+        all_models = self.model_manager.get_all_models()
+
+        # Validate or fallback model
+        available_model_ids = [
+            m.id
+            for m in all_models
+            if not m.requires_role or m.requires_role in user_roles
+        ]
+
+        selected_model = current_model
+        if selected_model not in available_model_ids:
+            selected_model = self.model_manager.get_default_model()
+            if available_model_ids and selected_model not in available_model_ids:
+                selected_model = available_model_ids[0]
+
+        return ThreadModel(
+            thread_id=str(uuid.uuid4()),
+            title="Neuer Chat",
+            prompt="",
+            messages=[],
+            state=ThreadStatus.NEW,
+            ai_model=selected_model,
+            active=True,
+        )
+
+    async def load_thread(
+        self, thread_id: str, user_id: str | int
+    ) -> ThreadModel | None:
+        """Load a thread from the database."""
+        async with get_asyncdb_session() as session:
+            # Ensure user_id is correct type if needed
+            user_id_val = (
+                int(user_id)
+                if isinstance(user_id, str) and user_id.isdigit()
+                else user_id
+            )
+
+            thread_entity = await thread_repo.find_by_thread_id_and_user(
+                session, thread_id, user_id_val
+            )
+
+            if not thread_entity:
+                return None
+
+            return ThreadModel(
+                thread_id=thread_entity.thread_id,
+                title=thread_entity.title,
+                state=ThreadStatus(thread_entity.state),
+                ai_model=thread_entity.ai_model,
+                active=thread_entity.active,
+                messages=[Message(**m) for m in thread_entity.messages],
+            )
+
+    async def save_thread(self, thread: ThreadModel, user_id: str | int) -> None:
+        """Persist or update a thread in the database."""
+        if not user_id:
+            logger.warning("Cannot save thread: No user ID provided")
+            return
+
+        try:
+            messages_dict = [m.model_dump() for m in thread.messages]
+            user_id_val = (
+                int(user_id)
+                if isinstance(user_id, str) and user_id.isdigit()
+                else user_id
+            )
+
+            async with get_asyncdb_session() as session:
+                existing = await thread_repo.find_by_thread_id_and_user(
+                    session, thread.thread_id, user_id_val
+                )
+
+                state_value = (
+                    thread.state.value
+                    if hasattr(thread.state, "value")
+                    else thread.state
+                )
+
+                if existing:
+                    existing.title = thread.title
+                    existing.state = state_value
+                    existing.ai_model = thread.ai_model
+                    existing.active = thread.active
+                    existing.messages = messages_dict
+                    # updated_at handled by DB/SQLModel defaults,
+                    # explicit save triggers it
+                    await thread_repo.save(session, existing)
+                else:
+                    new_thread = AssistantThread(
+                        thread_id=thread.thread_id,
+                        user_id=user_id_val,
+                        title=thread.title,
+                        state=state_value,
+                        ai_model=thread.ai_model,
+                        active=thread.active,
+                        messages=messages_dict,
+                    )
+                    await thread_repo.save(session, new_thread)
+
+            logger.debug("Saved thread to DB: %s", thread.thread_id)
+        except Exception as e:
+            logger.exception("Error saving thread %s: %s", thread.thread_id, e)

{appkit_assistant-0.15.1 → appkit_assistant-0.15.3}/src/appkit_assistant/components/message.py

@@ -4,11 +4,11 @@ import appkit_mantine as mn
 from appkit_assistant.backend.models import (
     Message,
     MessageType,
-)
-from appkit_assistant.state.thread_state import (
     Thinking,
     ThinkingStatus,
     ThinkingType,
+)
+from appkit_assistant.state.thread_state import (
     ThreadState,
 )
 from appkit_ui.components.collabsible import collabsible
@@ -229,6 +229,54 @@ class MessageComponent:
             style=message_styles,
         )
 
+    @staticmethod
+    def error_message(message: str) -> rx.Component:
+        return rx.hstack(
+            rx.avatar(
+                fallback="!",
+                size="3",
+                variant="soft",
+                radius="full",
+                margin_top="16px",
+                color_scheme="red",
+            ),
+            rx.callout(
+                message,
+                icon="triangle-alert",
+                color_scheme="red",
+                max_width="90%",
+                size="1",
+                padding="0.5em",
+                border_radius="9px",
+                margin_top="18px",
+            ),
+            style=message_styles,
+        )
+
+    @staticmethod
+    def system_message(message: str) -> rx.Component:
+        return rx.hstack(
+            rx.avatar(
+                fallback="⚙",
+                size="3",
+                variant="soft",
+                radius="full",
+                margin_top="16px",
+                color_scheme="gray",
+            ),
+            rx.callout(
+                message,
+                icon="info",
+                color_scheme="gray",
+                max_width="90%",
+                size="1",
+                padding="0.5em",
+                border_radius="9px",
+                margin_top="18px",
+            ),
+            style=message_styles,
+        )
+
     @staticmethod
     def render_message(
         message: Message,
@@ -245,6 +293,14 @@ class MessageComponent:
                     MessageType.ASSISTANT,
                     MessageComponent.assistant_message(message),
                 ),
+                (
+                    MessageType.ERROR,
+                    MessageComponent.error_message(message.text),
+                ),
+                (
+                    MessageType.SYSTEM,
+                    MessageComponent.system_message(message.text),
+                ),
                 MessageComponent.info_message(message.text),
             )
         )

{appkit_assistant-0.15.1 → appkit_assistant-0.15.3}/src/appkit_assistant/components/thread.py

@@ -155,101 +155,15 @@ class Assistant:
         #     ThreadState.set_suggestions(suggestions)
 
         return rx.flex(
-            # Hidden element with user_id for OAuth validation
-            rx.el.input(
-                id="mcp-oauth-user-id",
-                type="hidden",
-                value=ThreadState.current_user_id,
-            ),
-            # Hidden button for OAuth callback - triggered by storage event
-            rx.el.button(
-                id="mcp-oauth-success-trigger",
-                style={"display": "none"},
-                on_click=lambda: ThreadState.handle_mcp_oauth_success_from_js(),
-            ),
-            # OAuth listener for localStorage changes (cross-window)
-            rx.script(
-                """
-                (function() {
-                    // Prevent double processing
-                    if (window._mcpOAuthListenerInstalled) {
-                        console.log('[OAuth] Listener already installed, skipping');
-                        return;
-                    }
-                    window._mcpOAuthListenerInstalled = true;
-                    var processing = false;
-
-                    function getCurrentUserId() {
-                        var el = document.getElementById('mcp-oauth-user-id');
-                        return el ? el.value : '';
-                    }
-                    function processOAuthResult(data) {
-                        if (processing) {
-                            console.log('[OAuth] Already processing, skip');
-                            return false;
-                        }
-                        processing = true;
-
-                        var currentUserId = getCurrentUserId();
-                        console.log('[OAuth] Processing, userId:', data.userId,
-                            'current:', currentUserId);
-                        // Security: only process if user_id matches (or not set)
-                        if (data.userId && currentUserId &&
-                            String(data.userId) !== String(currentUserId)) {
-                            console.log('[OAuth] Ignoring - user mismatch');
-                            processing = false;
-                            return false;
-                        }
-                        window._mcpOAuthData = data;
-                        var btn = document.getElementById(
-                            'mcp-oauth-success-trigger'
-                        );
-                        if (btn) {
-                            console.log('[OAuth] Clicking trigger button');
-                            btn.click();
-                        }
-                        // Reset after short delay to allow for page navigation
-                        setTimeout(function() { processing = false; }, 5000);
-                        return true;
-                    }
-                    function checkLocalStorage() {
-                        if (processing) return false;
-                        var stored = localStorage.getItem('mcp-oauth-result');
-                        if (stored) {
-                            console.log('[OAuth] Found in localStorage');
-                            try {
-                                var data = JSON.parse(stored);
-                                if (data.type === 'mcp-oauth-success') {
-                                    localStorage.removeItem('mcp-oauth-result');
-                                    return processOAuthResult(data);
-                                }
-                            } catch(e) { console.error('[OAuth] Parse error:', e); }
-                        }
-                        return false;
-                    }
-                    console.log('[OAuth] Installing listeners');
-                    window.addEventListener('storage', function(event) {
-                        if (event.key === 'mcp-oauth-result') {
-                            checkLocalStorage();
-                        }
-                    });
-                    window.addEventListener('focus', function() {
-                        checkLocalStorage();
-                    });
-                    document.addEventListener('visibilitychange', function() {
-                        if (!document.hidden) checkLocalStorage();
-                    });
-                    var intervalId = setInterval(function() {
-                        if (checkLocalStorage()) clearInterval(intervalId);
-                    }, 2000);
-                    checkLocalStorage();
-                    window.addEventListener('message', function(event) {
-                        if (event.data && event.data.type === 'mcp-oauth-success') {
-                            processOAuthResult(event.data);
-                        }
-                    });
-                })();
-                """
+            # OAuth result handler - triggers when popup sets localStorage
+            # rx.LocalStorage(sync=True) auto-syncs, rx.cond re-renders on change
+            rx.cond(
+                ThreadState.oauth_result != "",
+                rx.box(
+                    on_mount=ThreadState.process_oauth_result,
+                    style={"display": "none"},
+                ),
+                rx.fragment(),
             ),
             rx.cond(
                 ThreadState.messages,

appkit_assistant-0.15.3/src/appkit_assistant/logic/response_accumulator.py

@@ -0,0 +1,219 @@
+import logging
+import uuid
+from typing import Any
+
+from appkit_assistant.backend.models import (
+    Chunk,
+    ChunkType,
+    Message,
+    MessageType,
+    Thinking,
+    ThinkingStatus,
+    ThinkingType,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class ResponseAccumulator:
+    """
+    Accumulates chunks from streaming response into structured data
+    (Messages, Thinking items, etc.) for UI display.
+    """
+
+    def __init__(self):
+        self.current_reasoning_session: str = ""
+        self.current_tool_session: str = ""
+        self.thinking_items: list[Thinking] = []
+        self.image_chunks: list[Chunk] = []
+        self.messages: list[Message] = []
+        self.show_thinking: bool = False
+        self.current_activity: str = ""
+
+        # State for auth/errors
+        self.pending_auth_server_id: str = ""
+        self.pending_auth_server_name: str = ""
+        self.pending_auth_url: str = ""
+        self.auth_required: bool = False
+        self.error: str | None = None
+
+    def attach_messages_ref(self, messages: list[Message]) -> None:
+        """Attach a reference to the mutable messages list from state."""
+        self.messages = messages
+
+    def process_chunk(self, chunk: Chunk) -> None:
+        """Process a single chunk and update internal state."""
+        if chunk.type == ChunkType.TEXT:
+            if self.messages and self.messages[-1].type == MessageType.ASSISTANT:
+                self.messages[-1].text += chunk.text
+
+        elif chunk.type in (ChunkType.THINKING, ChunkType.THINKING_RESULT):
+            self._handle_reasoning_chunk(chunk)
+
+        elif chunk.type in (
+            ChunkType.TOOL_CALL,
+            ChunkType.TOOL_RESULT,
+            ChunkType.ACTION,
+        ):
+            self._handle_tool_chunk(chunk)
+
+        elif chunk.type in (ChunkType.IMAGE, ChunkType.IMAGE_PARTIAL):
+            self.image_chunks.append(chunk)
+
+        elif chunk.type == ChunkType.COMPLETION:
+            self.show_thinking = False
+
+        elif chunk.type == ChunkType.AUTH_REQUIRED:
+            self._handle_auth_required_chunk(chunk)
+
+        elif chunk.type == ChunkType.ERROR:
+            # We append it to the message text if it's not a hard error,
+            # or creates a new message?
+            # Existing logic was appending a new message.
+            self.messages.append(Message(text=chunk.text, type=MessageType.ERROR))
+            self.error = chunk.text
+
+        else:
+            logger.warning("Unhandled chunk type: %s", chunk.type)
+
+    def _get_or_create_tool_session(self, chunk: Chunk) -> str:
+        tool_id = chunk.chunk_metadata.get("tool_id")
+        if tool_id:
+            self.current_tool_session = tool_id
+            return tool_id
+
+        if chunk.type == ChunkType.TOOL_CALL:
+            # Count existing tool calls
+            tool_count = sum(
+                1 for i in self.thinking_items if i.type == ThinkingType.TOOL_CALL
+            )
+            self.current_tool_session = f"tool_{tool_count}"
+            return self.current_tool_session
+
+        if self.current_tool_session:
+            return self.current_tool_session
+
+        # Fallback
+        tool_count = sum(
+            1 for i in self.thinking_items if i.type == ThinkingType.TOOL_CALL
+        )
+        self.current_tool_session = f"tool_{tool_count}"
+        return self.current_tool_session
+
+    def _handle_reasoning_chunk(self, chunk: Chunk) -> None:
+        if chunk.type == ChunkType.THINKING:
+            self.show_thinking = True
+            self.current_activity = "Denke nach..."
+
+        reasoning_session = self._get_or_create_reasoning_session(chunk)
+
+        status = ThinkingStatus.IN_PROGRESS
+        text = ""
+        if chunk.type == ChunkType.THINKING:
+            text = chunk.text
+        elif chunk.type == ChunkType.THINKING_RESULT:
+            status = ThinkingStatus.COMPLETED
+
+        item = self._get_or_create_thinking_item(
+            reasoning_session, ThinkingType.REASONING, text=text, status=status
+        )
+
+        if chunk.type == ChunkType.THINKING:
+            if item.text and item.text != text:
+                item.text += f"\n{chunk.text}"
+        elif chunk.type == ChunkType.THINKING_RESULT:
+            item.status = ThinkingStatus.COMPLETED
+            if chunk.text:
+                item.text += f" {chunk.text}"
+
+    def _get_or_create_reasoning_session(self, chunk: Chunk) -> str:
+        reasoning_session = chunk.chunk_metadata.get("reasoning_session")
+        if reasoning_session:
+            return reasoning_session
+
+        last_item = self.thinking_items[-1] if self.thinking_items else None
+
+        should_create_new = (
+            not self.current_reasoning_session
+            or (last_item and last_item.type == ThinkingType.TOOL_CALL)
+            or (
+                last_item
+                and last_item.type == ThinkingType.REASONING
+                and last_item.status == ThinkingStatus.COMPLETED
+            )
+        )
+
+        if should_create_new:
+            self.current_reasoning_session = f"reasoning_{uuid.uuid4().hex[:8]}"
+
+        return self.current_reasoning_session
+
+    def _handle_tool_chunk(self, chunk: Chunk) -> None:
+        tool_id = self._get_or_create_tool_session(chunk)
+
+        tool_name = chunk.chunk_metadata.get("tool_name", "Unknown")
+        if chunk.type == ChunkType.TOOL_CALL:
+            self.current_activity = f"Nutze Werkzeug: {tool_name}..."
+
+        status = ThinkingStatus.IN_PROGRESS
+        text = ""
+        parameters = None
+        result = None
+        error = None
+
+        if chunk.type == ChunkType.TOOL_CALL:
+            parameters = chunk.chunk_metadata.get("parameters", chunk.text)
+            text = chunk.chunk_metadata.get("description", "")
+        elif chunk.type == ChunkType.TOOL_RESULT:
+            is_error = (
+                "error" in chunk.text.lower()
+                or "failed" in chunk.text.lower()
+                or chunk.chunk_metadata.get("error")
+            )
+            status = ThinkingStatus.ERROR if is_error else ThinkingStatus.COMPLETED
+            result = chunk.text
+            if is_error:
+                error = chunk.text
+        else:
+            text = chunk.text
+
+        item = self._get_or_create_thinking_item(
+            tool_id,
+            ThinkingType.TOOL_CALL,
+            text=text,
+            status=status,
+            tool_name=tool_name,
+            parameters=parameters,
+            result=result,
+            error=error,
+        )
+
+        if chunk.type == ChunkType.TOOL_CALL:
+            item.parameters = parameters
+            item.text = text
+            if not item.tool_name or item.tool_name == "Unknown":
+                item.tool_name = tool_name
+            item.status = ThinkingStatus.IN_PROGRESS
+        elif chunk.type == ChunkType.TOOL_RESULT:
+            item.status = status
+            item.result = result
+            item.error = error
+        elif chunk.type == ChunkType.ACTION:
+            item.text += f"\n---\nAktion: {chunk.text}"
+
+    def _get_or_create_thinking_item(
+        self, item_id: str, thinking_type: ThinkingType, **kwargs: Any
+    ) -> Thinking:
+        for item in self.thinking_items:
+            if item.type == thinking_type and item.id == item_id:
+                return item
+
+        new_item = Thinking(type=thinking_type, id=item_id, **kwargs)
+        self.thinking_items.append(new_item)
+        return new_item
+
+    def _handle_auth_required_chunk(self, chunk: Chunk) -> None:
+        self.pending_auth_server_id = chunk.chunk_metadata.get("server_id", "")
+        self.pending_auth_server_name = chunk.chunk_metadata.get("server_name", "")
+        self.pending_auth_url = chunk.chunk_metadata.get("auth_url", "")
+        self.auth_required = True