@vezlo/assistant-server 2.2.1 → 2.3.0

package/dist/src/controllers/ChatController.js

@@ -13,6 +13,7 @@ class ChatController {
         const { historyLength } = options;
         this.chatHistoryLength = typeof historyLength === 'number' && historyLength > 0 ? historyLength : 2;
         this.intentService = options.intentService;
+        this.realtimePublisher = options.realtimePublisher;
     }
     // Create a new conversation
     async createConversation(req, res) {
@@ -96,15 +97,34 @@ class ChatController {
             }
             // Generate a unique thread ID for the conversation
             const threadId = `conv_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+            const now = new Date();
             const conversation = await this.storage.saveConversation({
                 threadId,
                 userId,
                 organizationId: companyId,
                 title: title || 'New Conversation',
                 messageCount: 0,
-                createdAt: new Date(),
-                updatedAt: new Date()
+                createdAt: now,
+                updatedAt: now,
+                lastMessageAt: now
             });
+            // Publish realtime update for new conversation
+            if (this.realtimePublisher && companyUuid) {
+                try {
+                    await this.realtimePublisher.publish(`company:${companyUuid}:conversations`, 'conversation:created', {
+                        conversation: {
+                            uuid: conversation.id,
+                            status: 'open',
+                            message_count: conversation.messageCount,
+                            last_message_at: conversation.lastMessageAt?.toISOString() || now.toISOString(),
+                            created_at: conversation.createdAt.toISOString()
+                        }
+                    });
+                }
+                catch (error) {
+                    logger_1.default.error('[ChatController] Failed to publish conversation:created event:', error);
+                }
+            }
             res.json({
                 uuid: conversation.id,
                 title: conversation.title,
@@ -146,9 +166,44 @@ class ChatController {
                 createdAt: new Date()
             });
             // Update conversation message count
+            const timestamp = new Date();
+            const newMessageCount = conversation.messageCount + 1;
             await this.storage.updateConversation(uuid, {
-                messageCount: conversation.messageCount + 1
+                messageCount: newMessageCount,
+                lastMessageAt: timestamp
             });
+            // Publish realtime update
+            if (this.realtimePublisher && conversation.organizationId) {
+                try {
+                    logger_1.default.info(`[ChatController] Fetching company UUID for organizationId: ${conversation.organizationId}`);
+                    const { data: company } = await this.supabase
+                        .from('vezlo_companies')
+                        .select('uuid')
+                        .eq('id', conversation.organizationId)
+                        .single();
+                    if (company?.uuid) {
+                        logger_1.default.info(`[ChatController] Publishing user message update for company: ${company.uuid}`);
+                        await this.realtimePublisher.publish(`company:${company.uuid}:conversations`, 'message:created', {
+                            conversation_uuid: uuid,
+                            message: {
+                                uuid: userMessage.id,
+                                content: userMessage.content,
+                                type: userMessage.role,
+                                author_id: null,
+                                created_at: userMessage.createdAt.toISOString()
+                            },
+                            conversation_update: {
+                                message_count: newMessageCount,
+                                last_message_at: timestamp.toISOString(),
+                                status: conversation.joinedAt ? 'in_progress' : 'open'
+                            }
+                        });
+                    }
+                }
+                catch (error) {
+                    logger_1.default.error('[ChatController] Failed to publish realtime update:', error);
+                }
+            }
             res.json({
                 uuid: userMessage.id,
                 conversation_uuid: uuid,
@@ -178,9 +233,19 @@ class ChatController {
             const conversationId = userMessage.conversationId;
             const userMessageContent = userMessage.content;
             // Get conversation context (recent messages)
-            const messages = await this.chatManager.getRecentMessages(conversationId, this.chatHistoryLength);
+            // Exclude the current user message to avoid duplication (it's added separately as the query)
+            const allMessages = await this.chatManager.getRecentMessages(conversationId, this.chatHistoryLength + 1);
+            const messages = allMessages.filter(msg => msg.id !== uuid).slice(-this.chatHistoryLength);
             logger_1.default.info(`📜 Retrieved ${messages.length} message(s) from conversation history (limit: ${this.chatHistoryLength})`);
             const conversation = await this.storage.getConversation(conversationId);
+            // Check if conversation has been joined by an agent
+            if (conversation?.joinedAt) {
+                res.status(400).json({
+                    error: 'Conversation is being handled by an agent',
+                    message: 'AI responses are disabled when an agent has joined the conversation'
+                });
+                return;
+            }
             // Run intent classification to decide handling strategy
             const intentResult = await this.classifyIntent(userMessageContent, messages);
             const handled = await this.handleIntentResult(intentResult, userMessage, conversationId, conversation, res);
@@ -199,8 +264,6 @@ class ChatController {
                     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
                     });
                     logger_1.default.info(`📊 Found knowledge base results: ${searchResults.length}`);
@@ -261,37 +324,360 @@ class ChatController {
             });
         }
     }
-    // Get conversation details with messages
+    // Get conversation details
     async getConversation(req, res) {
         try {
+            if (!req.profile) {
+                res.status(401).json({ error: 'Authentication required' });
+                return;
+            }
             const { uuid } = req.params;
             const conversation = await this.storage.getConversation(uuid);
             if (!conversation) {
                 res.status(404).json({ error: 'Conversation not found' });
                 return;
             }
-            const messages = await this.storage.getMessages(uuid, 50);
+            if (conversation.organizationId && conversation.organizationId !== req.profile.companyId) {
+                res.status(404).json({ error: 'Conversation not found' });
+                return;
+            }
+            const toIso = (date) => (date ? date.toISOString() : null);
+            const status = conversation.closedAt
+                ? 'closed'
+                : conversation.joinedAt
+                    ? 'in_progress'
+                    : 'open';
             res.json({
                 uuid: conversation.id,
                 title: conversation.title,
                 user_uuid: conversation.userId,
                 company_uuid: conversation.organizationId,
                 message_count: conversation.messageCount,
-                created_at: conversation.createdAt,
+                created_at: toIso(conversation.createdAt),
+                updated_at: toIso(conversation.updatedAt),
+                joined_at: toIso(conversation.joinedAt),
+                responded_at: toIso(conversation.respondedAt),
+                closed_at: toIso(conversation.closedAt),
+                last_message_at: toIso(conversation.lastMessageAt),
+                status
+            });
+        }
+        catch (error) {
+            logger_1.default.error('Get conversation error:', error);
+            res.status(500).json({
+                error: 'Failed to get conversation',
+                message: error instanceof Error ? error.message : 'Unknown error'
+            });
+        }
+    }
+    // Get conversation messages
+    async getConversationMessages(req, res) {
+        try {
+            if (!req.profile) {
+                res.status(401).json({ error: 'Authentication required' });
+                return;
+            }
+            const { uuid } = req.params;
+            const page = Math.max(1, parseInt(req.query.page || '1', 10) || 1);
+            const pageSizeRaw = parseInt(req.query.page_size || '50', 10);
+            const pageSize = Math.min(200, Math.max(1, isNaN(pageSizeRaw) ? 50 : pageSizeRaw));
+            const offset = (page - 1) * pageSize;
+            const orderParam = (req.query.order || 'desc').toLowerCase();
+            const order = orderParam === 'asc' ? 'asc' : 'desc';
+            const conversation = await this.storage.getConversation(uuid);
+            if (!conversation) {
+                res.status(404).json({ error: 'Conversation not found' });
+                return;
+            }
+            if (conversation.organizationId && conversation.organizationId !== req.profile.companyId) {
+                res.status(404).json({ error: 'Conversation not found' });
+                return;
+            }
+            const messages = await this.storage.getMessages(uuid, pageSize, offset, { order });
+            const hasMore = messages.length === pageSize;
+            const toIso = (date) => (date ? date.toISOString() : null);
+            res.json({
+                conversation_uuid: conversation.id,
+                order,
                 messages: messages.map(msg => ({
                     uuid: msg.id,
                     parent_message_uuid: msg.parentMessageId,
                     type: msg.role,
                     content: msg.content,
                     status: 'completed',
-                    created_at: msg.createdAt
-                }))
+                    created_at: toIso(msg.createdAt),
+                    author_id: msg.authorId ?? null
+                })),
+                pagination: {
+                    page,
+                    page_size: pageSize,
+                    has_more: hasMore,
+                    next_offset: hasMore ? offset + pageSize : null
+                }
             });
         }
         catch (error) {
-            logger_1.default.error('Get conversation error:', error);
+            logger_1.default.error('Get conversation messages error:', error);
             res.status(500).json({
-                error: 'Failed to get conversation',
+                error: 'Failed to get conversation messages',
+                message: error instanceof Error ? error.message : 'Unknown error'
+            });
+        }
+    }
+    // Join conversation
+    async joinConversation(req, res) {
+        try {
+            if (!req.user || !req.profile) {
+                res.status(401).json({ error: 'Authentication required' });
+                return;
+            }
+            const { uuid } = req.params;
+            const conversation = await this.storage.getConversation(uuid);
+            if (!conversation) {
+                res.status(404).json({ error: 'Conversation not found' });
+                return;
+            }
+            if (conversation.organizationId !== req.profile.companyId) {
+                res.status(404).json({ error: 'Conversation not found' });
+                return;
+            }
+            if (conversation.closedAt) {
+                res.status(400).json({ error: 'Conversation is closed' });
+                return;
+            }
+            const joinedAt = new Date();
+            await this.storage.updateConversation(uuid, {
+                joinedAt,
+                status: 'in_progress'
+            });
+            const systemMessage = await this.storage.saveMessage({
+                conversationId: uuid,
+                threadId: conversation.threadId,
+                role: 'system',
+                content: `${req.user.name} has joined the conversation.`,
+                createdAt: joinedAt,
+                authorId: parseInt(req.user.id)
+            });
+            const newMessageCount = conversation.messageCount + 1;
+            await this.storage.updateConversation(uuid, {
+                messageCount: newMessageCount,
+                lastMessageAt: joinedAt
+            });
+            if (this.realtimePublisher) {
+                try {
+                    const { data: company } = await this.supabase
+                        .from('vezlo_companies')
+                        .select('uuid')
+                        .eq('id', conversation.organizationId)
+                        .single();
+                    if (company?.uuid) {
+                        await this.realtimePublisher.publish(`company:${company.uuid}:conversations`, 'message:created', {
+                            conversation_uuid: uuid,
+                            message: {
+                                uuid: systemMessage.id,
+                                content: systemMessage.content,
+                                type: systemMessage.role,
+                                author_id: systemMessage.authorId,
+                                created_at: systemMessage.createdAt.toISOString()
+                            },
+                            conversation_update: {
+                                message_count: newMessageCount,
+                                last_message_at: joinedAt.toISOString(),
+                                joined_at: joinedAt.toISOString(),
+                                status: 'in_progress'
+                            }
+                        });
+                    }
+                }
+                catch (error) {
+                    logger_1.default.error('[ChatController] Failed to publish join conversation update:', error);
+                }
+            }
+            res.json({
+                success: true,
+                message: {
+                    uuid: systemMessage.id,
+                    content: systemMessage.content,
+                    type: systemMessage.role,
+                    author_id: systemMessage.authorId,
+                    created_at: systemMessage.createdAt.toISOString()
+                }
+            });
+        }
+        catch (error) {
+            logger_1.default.error('Join conversation error:', error);
+            res.status(500).json({
+                error: 'Failed to join conversation',
+                message: error instanceof Error ? error.message : 'Unknown error'
+            });
+        }
+    }
+    // Close conversation
+    async closeConversation(req, res) {
+        try {
+            if (!req.user || !req.profile) {
+                res.status(401).json({ error: 'Authentication required' });
+                return;
+            }
+            const { uuid } = req.params;
+            const conversation = await this.storage.getConversation(uuid);
+            if (!conversation) {
+                res.status(404).json({ error: 'Conversation not found' });
+                return;
+            }
+            if (conversation.organizationId !== req.profile.companyId) {
+                res.status(404).json({ error: 'Conversation not found' });
+                return;
+            }
+            if (conversation.closedAt) {
+                res.status(400).json({ error: 'Conversation is already closed' });
+                return;
+            }
+            const closedAt = new Date();
+            const systemMessage = await this.storage.saveMessage({
+                conversationId: uuid,
+                threadId: conversation.threadId,
+                role: 'system',
+                content: `${req.user.name} has closed the conversation.`,
+                createdAt: closedAt,
+                authorId: parseInt(req.user.id, 10)
+            });
+            const newMessageCount = conversation.messageCount + 1;
+            await this.storage.updateConversation(uuid, {
+                messageCount: newMessageCount,
+                lastMessageAt: closedAt,
+                closedAt
+            });
+            if (this.realtimePublisher) {
+                try {
+                    const { data: company } = await this.supabase
+                        .from('vezlo_companies')
+                        .select('uuid')
+                        .eq('id', conversation.organizationId)
+                        .single();
+                    if (company?.uuid) {
+                        await this.realtimePublisher.publish(`company:${company.uuid}:conversations`, 'message:created', {
+                            conversation_uuid: uuid,
+                            message: {
+                                uuid: systemMessage.id,
+                                content: systemMessage.content,
+                                type: systemMessage.role,
+                                author_id: systemMessage.authorId,
+                                created_at: systemMessage.createdAt.toISOString()
+                            },
+                            conversation_update: {
+                                message_count: newMessageCount,
+                                last_message_at: closedAt.toISOString(),
+                                joined_at: conversation.joinedAt?.toISOString() || null,
+                                closed_at: closedAt.toISOString(),
+                                status: 'closed'
+                            }
+                        });
+                    }
+                }
+                catch (error) {
+                    logger_1.default.error('[ChatController] Failed to publish close conversation update:', error);
+                }
+            }
+            res.json({
+                success: true,
+                message: {
+                    uuid: systemMessage.id,
+                    content: systemMessage.content,
+                    type: systemMessage.role,
+                    author_id: systemMessage.authorId,
+                    created_at: systemMessage.createdAt.toISOString()
+                }
+            });
+        }
+        catch (error) {
+            logger_1.default.error('Close conversation error:', error);
+            res.status(500).json({
+                error: 'Failed to close conversation',
+                message: error instanceof Error ? error.message : 'Unknown error'
+            });
+        }
+    }
+    // Send agent message
+    async sendAgentMessage(req, res) {
+        try {
+            if (!req.user || !req.profile) {
+                res.status(401).json({ error: 'Authentication required' });
+                return;
+            }
+            const { uuid } = req.params;
+            const { content } = req.body;
+            if (!content) {
+                res.status(400).json({ error: 'content is required' });
+                return;
+            }
+            const conversation = await this.storage.getConversation(uuid);
+            if (!conversation) {
+                res.status(404).json({ error: 'Conversation not found' });
+                return;
+            }
+            if (conversation.organizationId !== req.profile.companyId) {
+                res.status(404).json({ error: 'Conversation not found' });
+                return;
+            }
+            if (conversation.closedAt) {
+                res.status(400).json({ error: 'Conversation is closed' });
+                return;
+            }
+            const agentMessage = await this.storage.saveMessage({
+                conversationId: uuid,
+                threadId: conversation.threadId,
+                role: 'agent',
+                content,
+                createdAt: new Date(),
+                authorId: parseInt(req.user.id)
+            });
+            const newMessageCount = conversation.messageCount + 1;
+            const timestamp = new Date();
+            await this.storage.updateConversation(uuid, {
+                messageCount: newMessageCount,
+                lastMessageAt: timestamp
+            });
+            if (this.realtimePublisher) {
+                try {
+                    const { data: company } = await this.supabase
+                        .from('vezlo_companies')
+                        .select('uuid')
+                        .eq('id', conversation.organizationId)
+                        .single();
+                    if (company?.uuid) {
+                        await this.realtimePublisher.publish(`company:${company.uuid}:conversations`, 'message:created', {
+                            conversation_uuid: uuid,
+                            message: {
+                                uuid: agentMessage.id,
+                                content: agentMessage.content,
+                                type: agentMessage.role,
+                                author_id: agentMessage.authorId,
+                                created_at: agentMessage.createdAt.toISOString()
+                            },
+                            conversation_update: {
+                                message_count: newMessageCount,
+                                last_message_at: timestamp.toISOString()
+                            }
+                        });
+                    }
+                }
+                catch (error) {
+                    logger_1.default.error('[ChatController] Failed to publish agent message update:', error);
+                }
+            }
+            res.json({
+                uuid: agentMessage.id,
+                content: agentMessage.content,
+                type: agentMessage.role,
+                author_id: agentMessage.authorId,
+                created_at: agentMessage.createdAt.toISOString()
+            });
+        }
+        catch (error) {
+            logger_1.default.error('Send agent message error:', error);
+            res.status(500).json({
+                error: 'Failed to send agent message',
                 message: error instanceof Error ? error.message : 'Unknown error'
             });
         }
@@ -303,14 +689,42 @@ class ChatController {
                 res.status(401).json({ error: 'Authentication required' });
                 return;
             }
-            const conversations = await this.storage.getUserConversations(req.user.id, req.profile?.companyId || undefined);
+            const page = Math.max(1, parseInt(req.query.page || '1', 10) || 1);
+            const pageSizeRaw = parseInt(req.query.page_size || '20', 10);
+            const pageSize = Math.min(100, Math.max(1, isNaN(pageSizeRaw) ? 20 : pageSizeRaw));
+            const offset = (page - 1) * pageSize;
+            const orderParam = req.query.order_by || 'last_message_at';
+            const orderBy = orderParam === 'created_at' ? 'updated_at' : 'last_message_at';
+            const { conversations, total } = await this.storage.getUserConversations(req.user.id, req.profile.companyId, {
+                limit: pageSize,
+                offset,
+                orderBy: orderBy
+            });
+            const toIso = (date) => (date ? date.toISOString() : null);
             res.json({
                 conversations: conversations.map(conversation => ({
                     uuid: conversation.id,
                     title: conversation.title,
                     message_count: conversation.messageCount,
-                    created_at: conversation.createdAt
-                }))
+                    created_at: toIso(conversation.createdAt),
+                    updated_at: toIso(conversation.updatedAt),
+                    joined_at: toIso(conversation.joinedAt),
+                    responded_at: toIso(conversation.respondedAt),
+                    closed_at: toIso(conversation.closedAt),
+                    last_message_at: toIso(conversation.lastMessageAt),
+                    status: conversation.closedAt
+                        ? 'closed'
+                        : conversation.joinedAt
+                            ? 'in_progress'
+                            : 'open'
+                })),
+                pagination: {
+                    page,
+                    page_size: pageSize,
+                    total,
+                    total_pages: Math.max(1, Math.ceil(total / pageSize)),
+                    has_more: offset + conversations.length < total
+                }
             });
         }
         catch (error) {
@@ -415,75 +829,33 @@ class ChatController {
             return true;
         }
         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, use LLM-generated response from intent classification
+        if (result.intent !== 'knowledge') {
+            const responseContent = result.response || this.getFallbackResponse(result.intent);
+            await this.respondWithAssistantMessage({
+                conversation,
+                conversationId,
+                parentMessageId: userMessage.id,
+                content: responseContent
+            }, res);
+            return true;
         }
+        // Knowledge intent - proceed to RAG flow
+        logger_1.default.info('📚 Intent requires knowledge lookup; proceeding with RAG flow.');
+        return false;
+    }
+    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({
@@ -514,10 +886,55 @@ class ChatController {
         });
         if (options.conversation) {
             const nextCount = (options.conversation.messageCount || 0) + 1;
+            const timestamp = new Date();
             await this.storage.updateConversation(options.conversationId, {
-                messageCount: nextCount
+                messageCount: nextCount,
+                lastMessageAt: timestamp
             });
             options.conversation.messageCount = nextCount;
+            options.conversation.lastMessageAt = timestamp;
+            // Publish realtime update
+            if (this.realtimePublisher && options.conversation.organizationId) {
+                try {
+                    logger_1.default.info(`[ChatController] Fetching company UUID for assistant message, organizationId: ${options.conversation.organizationId}`);
+                    const { data: company } = await this.supabase
+                        .from('vezlo_companies')
+                        .select('uuid')
+                        .eq('id', options.conversation.organizationId)
+                        .single();
+                    if (company?.uuid) {
+                        logger_1.default.info(`[ChatController] Publishing assistant message update for company: ${company.uuid}`);
+                        await this.realtimePublisher.publish(`company:${company.uuid}:conversations`, 'message:created', {
+                            conversation_uuid: options.conversationId,
+                            message: {
+                                uuid: assistantMessage.id,
+                                content: assistantMessage.content,
+                                type: assistantMessage.role,
+                                author_id: null,
+                                created_at: assistantMessage.createdAt.toISOString()
+                            },
+                            conversation_update: {
+                                message_count: nextCount,
+                                last_message_at: timestamp.toISOString()
+                            }
+                        });
+                    }
+                    else {
+                        logger_1.default.warn(`[ChatController] No company UUID found for organizationId: ${options.conversation.organizationId}`);
+                    }
+                }
+                catch (error) {
+                    logger_1.default.error('[ChatController] Failed to publish realtime update:', error);
+                }
+            }
+            else {
+                if (!this.realtimePublisher) {
+                    logger_1.default.warn('[ChatController] Realtime publisher not available for assistant message');
+                }
+                if (!options.conversation.organizationId) {
+                    logger_1.default.warn('[ChatController] No organizationId in conversation for assistant message');
+                }
+            }
         }
         return assistantMessage;
     }