@vezlo/assistant-server 2.2.2 → 2.4.0

package/dist/src/controllers/ChatController.js

@@ -246,84 +246,202 @@ class ChatController {
                 });
                 return;
             }
+            // Set up Server-Sent Events (SSE) headers for streaming (always stream, consistent format)
+            res.setHeader('Content-Type', 'text/event-stream');
+            res.setHeader('Cache-Control', 'no-cache');
+            res.setHeader('Connection', 'keep-alive');
+            res.setHeader('X-Accel-Buffering', 'no'); // Disable nginx buffering
             // Run intent classification to decide handling strategy
             const intentResult = await this.classifyIntent(userMessageContent, messages);
-            const handled = await this.handleIntentResult(intentResult, userMessage, conversationId, conversation, res);
-            if (handled) {
-                return;
+            const intentResponse = await this.handleIntentResult(intentResult, userMessage, conversationId, conversation);
+            let accumulatedContent = '';
+            let assistantMessageId;
+            try {
+                // If intent returned a response (non-knowledge intent), stream it
+                if (intentResponse) {
+                    logger_1.default.info(`📤 Streaming intent response for: ${intentResult.intent}`);
+                    await this.streamTextContent(intentResponse, res);
+                    accumulatedContent = intentResponse;
+                }
+                else {
+                    // Knowledge intent - proceed with RAG flow and stream AI response
+                    logger_1.default.info('📚 Streaming knowledge-based response');
+                    // Get knowledge base search results if available
+                    const aiService = this.chatManager.aiService;
+                    let knowledgeResults = null;
+                    // Get conversation to extract company_id for knowledge base search
+                    const companyIdRaw = req.profile?.companyId || conversation?.organizationId;
+                    const companyId = companyIdRaw ? (typeof companyIdRaw === 'string' ? parseInt(companyIdRaw, 10) : companyIdRaw) : undefined;
+                    if (aiService && aiService.knowledgeBaseService) {
+                        try {
+                            logger_1.default.info(`🔍 Searching KB: query="${userMessageContent.substring(0, 50)}...", companyId=${companyId}`);
+                            const searchResults = await aiService.knowledgeBaseService.search(userMessageContent, {
+                                limit: 5,
+                                company_id: companyId
+                            });
+                            logger_1.default.info(`📊 Found knowledge base results: ${searchResults.length}`);
+                            if (searchResults.length > 0) {
+                                knowledgeResults = '\n\nRelevant information from knowledge base:\n';
+                                searchResults.forEach((result) => {
+                                    const title = result.title || 'Untitled';
+                                    const content = result.content || '';
+                                    if (content.trim()) {
+                                        knowledgeResults += `- ${title}: ${content}\n`;
+                                    }
+                                });
+                                // Verify we actually have meaningful content (not just the header)
+                                const headerLength = '\n\nRelevant information from knowledge base:\n'.length;
+                                if (knowledgeResults.length > headerLength + 10) {
+                                    logger_1.default.info(`✅ Knowledge context prepared (${knowledgeResults.length} chars, ${searchResults.length} results)`);
+                                    // Log first 200 chars for debugging
+                                    logger_1.default.info(`📝 Knowledge preview: ${knowledgeResults.substring(0, 200)}...`);
+                                }
+                                else {
+                                    logger_1.default.warn(`⚠️  Knowledge results found but content is empty or too short (${knowledgeResults.length} chars), treating as no results`);
+                                    knowledgeResults = '';
+                                }
+                            }
+                            else {
+                                knowledgeResults = '';
+                                logger_1.default.info('⚠️  No knowledge base results found; will return appropriate fallback response');
+                            }
+                        }
+                        catch (error) {
+                            console.error('❌ Failed to search knowledge base:', error);
+                            logger_1.default.error('Failed to search knowledge base:', error);
+                            knowledgeResults = null;
+                        }
+                    }
+                    else {
+                        logger_1.default.warn('⚠️  AI service or knowledge base service not available');
+                    }
+                    // Build context for AI
+                    const chatContext = {
+                        conversationHistory: messages.map(msg => ({
+                            role: msg.role,
+                            content: msg.content
+                        })),
+                        knowledgeResults: knowledgeResults ?? undefined
+                    };
+                    // Stream response from OpenAI
+                    logger_1.default.info('🔄 Starting OpenAI stream...');
+                    const stream = aiService.generateResponseStream(userMessageContent, chatContext);
+                    let chunkCount = 0;
+                    for await (const { chunk, done, fullContent } of stream) {
+                        chunkCount++;
+                        // Always send the chunk (even if empty with done flag)
+                        const chunkData = JSON.stringify({
+                            type: 'chunk',
+                            content: chunk,
+                            done: done || false // Include done flag
+                        });
+                        res.write(`data: ${chunkData}\n\n`);
+                        if (res.flush)
+                            res.flush();
+                        // Update accumulated content
+                        if (chunk) {
+                            accumulatedContent += chunk;
+                        }
+                        // Log first and last chunks
+                        if (chunkCount === 1) {
+                            logger_1.default.info(`📤 First chunk sent: "${chunk.substring(0, 30)}..."`);
+                        }
+                        if (done && fullContent) {
+                            accumulatedContent = fullContent;
+                            logger_1.default.info(`🏁 Stream complete: ${chunkCount} chunks sent, ${fullContent.length} total chars`);
+                        }
+                    }
+                }
+                // Save the message after streaming completes
+                try {
+                    const assistantMessage = await this.saveAssistantMessage({
+                        conversation,
+                        conversationId,
+                        parentMessageId: uuid,
+                        content: accumulatedContent,
+                        toolResults: []
+                    });
+                    assistantMessageId = assistantMessage.id;
+                    // Send completion event with final message metadata (no content - already streamed)
+                    const completionData = JSON.stringify({
+                        type: 'completion',
+                        uuid: assistantMessage.id,
+                        parent_message_uuid: uuid,
+                        status: 'completed',
+                        created_at: assistantMessage.createdAt.toISOString()
+                    });
+                    res.write(`data: ${completionData}\n\n`);
+                }
+                catch (saveError) {
+                    logger_1.default.error('Failed to save assistant message:', saveError);
+                    const errorData = JSON.stringify({
+                        type: 'error',
+                        error: 'Failed to save message',
+                        message: saveError instanceof Error ? saveError.message : 'Unknown error'
+                    });
+                    res.write(`data: ${errorData}\n\n`);
+                }
+                // Close the stream
+                res.end();
             }
-            // Get knowledge base search results if available
-            const aiService = this.chatManager.aiService;
-            let knowledgeResults = null; // null = search done, no results; undefined = not searched yet
-            // Get conversation to extract company_id for knowledge base search
-            // Note: profile.companyId and conversation.organizationId should contain integer IDs (as strings)
-            const companyIdRaw = req.profile?.companyId || conversation?.organizationId;
-            const companyId = companyIdRaw ? (typeof companyIdRaw === 'string' ? parseInt(companyIdRaw, 10) : companyIdRaw) : undefined;
-            if (aiService && aiService.knowledgeBaseService) {
+            catch (streamError) {
+                logger_1.default.error('Streaming error:', streamError);
+                // Try to send error to client if connection is still open
                 try {
-                    logger_1.default.info(`🔍 Searching KB: query="${userMessageContent.substring(0, 50)}...", companyId=${companyId}`);
-                    const searchResults = await aiService.knowledgeBaseService.search(userMessageContent, {
-                        limit: 5,
-                        threshold: 0.5, // Balanced precision/recall (0.5 is industry standard)
-                        type: 'semantic', // Modern RAG best practice: semantic-only for better context
-                        company_id: companyId
+                    const errorData = JSON.stringify({
+                        type: 'error',
+                        error: 'Failed to generate response',
+                        message: streamError instanceof Error ? streamError.message : 'Unknown error'
                     });
-                    logger_1.default.info(`📊 Found knowledge base results: ${searchResults.length}`);
-                    if (searchResults.length > 0) {
-                        knowledgeResults = '\n\nRelevant information from knowledge base:\n';
-                        searchResults.forEach((result) => {
-                            knowledgeResults += `- ${result.title}: ${result.content}\n`;
+                    res.write(`data: ${errorData}\n\n`);
+                    res.end();
+                }
+                catch (writeError) {
+                    logger_1.default.error('Failed to send error to client:', writeError);
+                    res.end();
+                }
+                // If we have accumulated content but failed to save, try to save it
+                if (accumulatedContent && !assistantMessageId) {
+                    try {
+                        await this.saveAssistantMessage({
+                            conversation,
+                            conversationId,
+                            parentMessageId: uuid,
+                            content: accumulatedContent,
+                            toolResults: []
                         });
-                        logger_1.default.info('✅ Knowledge context prepared');
                     }
-                    else {
-                        // Set to empty string to indicate search was done but no results found
-                        knowledgeResults = '';
-                        logger_1.default.info('⚠️  No knowledge base results found; will return appropriate fallback response');
+                    catch (saveError) {
+                        logger_1.default.error('Failed to save partial message after stream error:', saveError);
                     }
                 }
-                catch (error) {
-                    console.error('❌ Failed to search knowledge base:', error);
-                    logger_1.default.error('Failed to search knowledge base:', error);
-                    // On error, set to null so AIService knows search was attempted
-                    knowledgeResults = null;
-                }
-            }
-            else {
-                logger_1.default.warn('⚠️  AI service or knowledge base service not available');
             }
-            // Build context for AI
-            const chatContext = {
-                conversationHistory: messages.map(msg => ({
-                    role: msg.role,
-                    content: msg.content
-                })),
-                knowledgeResults: knowledgeResults ?? undefined // Convert null to undefined for cleaner check
-            };
-            // Generate AI response using the actual user message content
-            const response = await aiService.generateResponse(userMessageContent, chatContext);
-            const assistantMessage = await this.saveAssistantMessage({
-                conversation,
-                conversationId,
-                parentMessageId: uuid,
-                content: response.content,
-                toolResults: response.toolResults
-            });
-            res.json({
-                uuid: assistantMessage.id,
-                parent_message_uuid: uuid,
-                type: 'assistant',
-                content: response.content,
-                status: 'completed',
-                created_at: assistantMessage.createdAt.toISOString()
-            });
         }
         catch (error) {
             logger_1.default.error('Generate response error:', error);
-            res.status(500).json({
-                error: 'Failed to generate response',
-                message: error instanceof Error ? error.message : 'Unknown error'
-            });
+            // If headers haven't been sent yet, send JSON error
+            if (!res.headersSent) {
+                res.status(500).json({
+                    error: 'Failed to generate response',
+                    message: error instanceof Error ? error.message : 'Unknown error'
+                });
+            }
+            else {
+                // Headers already sent, try to send SSE error
+                try {
+                    const errorData = JSON.stringify({
+                        type: 'error',
+                        error: 'Failed to generate response',
+                        message: error instanceof Error ? error.message : 'Unknown error'
+                    });
+                    res.write(`data: ${errorData}\n\n`);
+                    res.end();
+                }
+                catch (writeError) {
+                    logger_1.default.error('Failed to send error to client:', writeError);
+                    res.end();
+                }
+            }
         }
     }
     // Get conversation details
@@ -756,7 +874,7 @@ class ChatController {
             });
         }
     }
-    // Submit message feedback
+    // Submit message feedback (create or update) - Public API
     async submitFeedback(req, res) {
         try {
             const { message_uuid, rating, category, comment, suggested_improvement } = req.body;
@@ -764,25 +882,26 @@ class ChatController {
                 res.status(400).json({ error: 'message_uuid and rating are required' });
                 return;
             }
-            if (!req.profile) {
-                res.status(401).json({ error: 'Authentication required' });
-                return;
-            }
             // Get the message to find its conversationId
             const message = await this.storage.getMessageById(message_uuid);
             if (!message) {
                 res.status(404).json({ error: 'Message not found' });
                 return;
             }
+            // Use authenticated user ID if available, otherwise use default anonymous user (1)
+            const userId = req.user?.id?.toString() || '1';
+            // Check if feedback already exists for this message and user
+            const existingFeedback = await this.storage.getFeedbackByMessageAndUser(message_uuid, userId);
             const feedback = await this.storage.saveFeedback({
+                id: existingFeedback?.id, // Include ID if exists (will update instead of create)
                 messageId: message_uuid,
                 conversationId: message.conversationId,
-                userId: req.user.id,
+                userId,
                 rating,
                 category,
                 comment,
                 suggestedImprovement: suggested_improvement,
-                createdAt: new Date()
+                createdAt: existingFeedback?.createdAt || new Date()
             });
             res.json({
                 success: true,
@@ -805,6 +924,36 @@ class ChatController {
             });
         }
     }
+    // Delete/undo message feedback - Public API
+    async deleteFeedback(req, res) {
+        try {
+            const { uuid } = req.params;
+            if (!uuid) {
+                res.status(400).json({ error: 'Feedback UUID is required' });
+                return;
+            }
+            // Verify feedback exists
+            const feedback = await this.storage.getFeedbackById(uuid);
+            if (!feedback) {
+                res.status(404).json({ error: 'Feedback not found' });
+                return;
+            }
+            // For public API, allow deletion by UUID only (no user verification)
+            // This is acceptable since feedback UUIDs are unique and not easily guessable
+            await this.storage.deleteFeedback(uuid);
+            res.json({
+                success: true,
+                message: 'Feedback deleted successfully'
+            });
+        }
+        catch (error) {
+            logger_1.default.error('Delete feedback error:', error);
+            res.status(500).json({
+                error: 'Failed to delete feedback',
+                message: error instanceof Error ? error.message : 'Unknown error'
+            });
+        }
+    }
     async classifyIntent(message, history) {
         if (!this.intentService) {
             return {
@@ -820,86 +969,63 @@ class ChatController {
             conversationHistory: resolvedHistory
         });
     }
-    async handleIntentResult(result, userMessage, conversationId, conversation, res) {
+    /**
+     * Handle intent classification result
+     * Returns response content if non-knowledge intent, null if knowledge intent
+     */
+    async handleIntentResult(result, userMessage, conversationId, conversation) {
         if (result.needsGuardrail && result.intent !== 'guardrail') {
-            await this.respondWithAssistantMessage({
-                conversation,
-                conversationId,
-                parentMessageId: userMessage.id,
-                content: `I can help with documentation or implementation guidance, but I can't share credentials or confidential configuration. Please contact your system administrator or support for access.`
-            }, res);
-            return true;
+            logger_1.default.info('🛡️ Guardrail triggered');
+            return `I can help with documentation or implementation guidance, but I can't share credentials or confidential configuration. Please contact your system administrator or support for access.`;
         }
         logger_1.default.info(`🧾 Intent result: ${result.intent}${result.needsGuardrail ? ' (guardrail triggered)' : ''}`);
-        switch (result.intent) {
-            case 'greeting':
-                await this.respondWithAssistantMessage({
-                    conversation,
-                    conversationId,
-                    parentMessageId: userMessage.id,
-                    content: 'Hello! How can I help you today?'
-                }, res);
-                return true;
-            case 'personality':
-                // Get assistant name and organization from environment
-                const assistantName = process.env.ASSISTANT_NAME || 'AI Assistant';
-                const orgName = process.env.ORGANIZATION_NAME || 'Your Organization';
-                await this.respondWithAssistantMessage({
-                    conversation,
-                    conversationId,
-                    parentMessageId: userMessage.id,
-                    content: `I'm ${assistantName}, your AI assistant for ${orgName}. I help teams understand and work with the ${orgName} platform by answering questions about features, documentation, and technical details. How can I assist you today?`
-                }, res);
-                return true;
-            case 'clarification':
-                await this.respondWithAssistantMessage({
-                    conversation,
-                    conversationId,
-                    parentMessageId: userMessage.id,
-                    content: "I'm not sure I understood. Could you clarify what you need help with?"
-                }, res);
-                return true;
-            case 'guardrail':
-                await this.respondWithAssistantMessage({
-                    conversation,
-                    conversationId,
-                    parentMessageId: userMessage.id,
-                    content: `I can help with documentation or implementation guidance, but I can't share credentials or confidential configuration. Please contact your system administrator or support for access.`
-                }, res);
-                return true;
-            case 'human_support_email':
-                await this.respondWithAssistantMessage({
-                    conversation,
-                    conversationId,
-                    parentMessageId: userMessage.id,
-                    content: `Thanks for sharing your email. Our team will reach out soon—response times may vary depending on support volume.`
-                }, res);
-                logger_1.default.info('📨 Recorded human support email from user.');
-                return true;
-            case 'human_support_request':
-                if (result.contactEmail) {
-                    await this.respondWithAssistantMessage({
-                        conversation,
-                        conversationId,
-                        parentMessageId: userMessage.id,
-                        content: `Thanks for sharing your email. Our team will reach out soon—response times may vary depending on support volume.`
-                    }, res);
-                    logger_1.default.info('📨 Human support request with email handled in a single step.');
-                }
-                else {
-                    await this.respondWithAssistantMessage({
-                        conversation,
-                        conversationId,
-                        parentMessageId: userMessage.id,
-                        content: 'I can connect you with a human teammate. Please share your email address so we can follow up.'
-                    }, res);
-                    logger_1.default.info('🙋 Human support requested; awaiting email from user.');
-                }
-                return true;
-            default:
-                logger_1.default.info('📚 Intent requires knowledge lookup; proceeding with RAG flow.');
-                return false;
+        // For non-knowledge intents, return the response content to be streamed
+        if (result.intent !== 'knowledge') {
+            const responseContent = result.response || this.getFallbackResponse(result.intent);
+            return responseContent;
         }
+        // Knowledge intent - proceed to RAG flow (return null to indicate streaming will happen later)
+        logger_1.default.info('📚 Intent requires knowledge lookup; proceeding with RAG flow.');
+        return null;
+    }
+    /**
+     * Stream text content word by word to simulate streaming
+     * This ensures consistent SSE format for all responses
+     */
+    async streamTextContent(content, res) {
+        const words = content.split(' ');
+        const chunkSize = 2; // Stream 2 words at a time for smoother experience
+        const totalChunks = Math.ceil(words.length / chunkSize);
+        for (let i = 0; i < words.length; i += chunkSize) {
+            const chunk = words.slice(i, i + chunkSize).join(' ') + (i + chunkSize < words.length ? ' ' : '');
+            const chunkIndex = Math.floor(i / chunkSize) + 1;
+            const isLastChunk = chunkIndex === totalChunks;
+            const chunkData = JSON.stringify({
+                type: 'chunk',
+                content: chunk,
+                done: isLastChunk // Mark last chunk with done: true
+            });
+            res.write(`data: ${chunkData}\n\n`);
+            // Flush the response to ensure chunks are sent immediately
+            if (res.flush) {
+                res.flush();
+            }
+            // Delay for smooth streaming effect (30ms for better visibility)
+            await new Promise(resolve => setTimeout(resolve, 30));
+        }
+    }
+    getFallbackResponse(intent) {
+        // Fallback responses in case LLM doesn't generate one (shouldn't happen, but safety net)
+        const fallbacks = {
+            greeting: 'Hello! How can I help you today?',
+            acknowledgment: "You're welcome! Let me know if you need anything else.",
+            personality: `I'm ${process.env.ASSISTANT_NAME || 'AI Assistant'}, your AI assistant for ${process.env.ORGANIZATION_NAME || 'Your Organization'}.`,
+            clarification: "I'm not sure I understood. Could you clarify what you need help with?",
+            guardrail: "I can help with documentation or implementation guidance, but I can't share credentials or confidential configuration.",
+            human_support_request: "I'd be happy to connect you with our support team. Could you please provide your email address?",
+            human_support_email: "Thank you! Our support team will reach out to you shortly."
+        };
+        return fallbacks[intent] || "I'm here to help. What would you like to know?";
     }
     async respondWithAssistantMessage(payload, res) {
         const assistantMessage = await this.saveAssistantMessage({