Fix chat name generation by filtering user messages (#1555)

Fixes OPS-2963.

## Additional Notes

- We were sending the whole chat history (including user, assistant and
reasoning) messages which made the LLMs misbehave in several ways like
schema errors, hallucinations and outputting part of reasoning messages
as chat name
- Now we only send user messages to the LLM to generate a name and it
works. I've tested with Vertex (Claude and Gemini), GPT (o1, 4o, 5,
5-mini, 5-nano)

### Before and After the change with Vertex provider:

- LLM responded with a sentence from reasoning messages.

<img width="1080" height="471" alt="Screenshot 2025-11-03 at 6 14 23 PM"
src="https://github.com/user-attachments/assets/da89cf8c-87cb-43f5-a329-0657403bd3f1"
/>
<img width="1080" height="471" alt="Screenshot 2025-11-03 at 6 15 05 PM"
src="https://github.com/user-attachments/assets/45b8b9d2-7ad1-4fc1-8ac2-b38f510e9c4c"
/>

### With GPT-5 Nano (Before and after the change):

<img width="1080" height="471" alt="Screenshot 2025-11-03 at 6 17 11 PM"
src="https://github.com/user-attachments/assets/5ac76e82-7796-4be3-ac24-b2957414fb27"
/>
<img width="1080" height="471" alt="Screenshot 2025-11-03 at 6 17 55 PM"
src="https://github.com/user-attachments/assets/029f316b-b11e-4b65-8b2a-f4e6083380ff"
/>

Author: ravikiranvm

packages/server/api/src/app/ai/chat/ai-mcp-chat.controller.ts

@@ -20,7 +20,7 @@ import {
   UpdateChatModelRequest,
   UpdateChatModelResponse,
 } from '@openops/shared';
-import { ModelMessage } from 'ai';
+import { ModelMessage, UserModelMessage } from 'ai';
 import { FastifyReply } from 'fastify';
 import { StatusCodes } from 'http-status-codes';
 import {
@@ -243,7 +243,19 @@ export const aiMCPChatController: FastifyPluginAsyncTypebox = async (app) => {
         return await reply.code(200).send({ chatName: DEFAULT_CHAT_NAME });
       }
 
-      const rawChatName = await generateChatName(chatHistory, projectId);
+      const userMessages = chatHistory.filter(
+        (msg): msg is UserModelMessage =>
+          msg &&
+          typeof msg === 'object' &&
+          'role' in msg &&
+          msg.role === 'user',
+      );
+
+      if (userMessages.length === 0) {
+        return await reply.code(200).send({ chatName: DEFAULT_CHAT_NAME });
+      }
+
+      const rawChatName = await generateChatName(userMessages, projectId);
       const chatName = rawChatName.trim() || DEFAULT_CHAT_NAME;
 
       await updateChatName(chatId, userId, projectId, chatName);

packages/server/api/test/unit/ai/ai-mcp-chat.controller.test.ts

@@ -376,9 +376,19 @@ describe('AI MCP Chat Controller - Tool Service Interactions', () => {
       expect(mockReply.send).toHaveBeenCalledWith({
         chatName: 'AWS Cost Optimization',
       });
+      expect(generateChatName).toHaveBeenCalledWith(
+        [{ role: 'user', content: 'How do I optimize AWS costs?' }],
+        'test-project-id',
+      );
+      expect(updateChatName).toHaveBeenCalledWith(
+        'test-chat-id',
+        'test-user-id',
+        'test-project-id',
+        'AWS Cost Optimization',
+      );
     });
 
-    it('should return "New Chat" for empty messages', async () => {
+    it('should return "New Chat" for empty chatHistory', async () => {
       (getConversation as jest.Mock).mockResolvedValue({ chatHistory: [] });
 
       await postHandler(
@@ -387,10 +397,102 @@ describe('AI MCP Chat Controller - Tool Service Interactions', () => {
       );
 
       expect(mockReply.code).toHaveBeenCalledWith(200);
-      expect(mockReply.send).toHaveBeenCalledWith({ chatName: 'New Chat' });
+      expect(mockReply.send).toHaveBeenCalledWith({
+        chatName: 'New Chat',
+      });
+      expect(generateChatName).not.toHaveBeenCalled();
+      expect(updateChatName).not.toHaveBeenCalled();
+    });
+
+    it('should return "New Chat" when chatHistory has no user messages', async () => {
+      (getConversation as jest.Mock).mockResolvedValue({
+        chatHistory: [
+          { role: 'assistant', content: 'Some response' },
+          { role: 'system', content: 'System message' },
+          {
+            role: 'tool',
+            content: [{ type: 'tool-result', toolCallId: '123' }],
+          },
+        ],
+      });
+
+      await postHandler(
+        { ...mockRequest, body: { chatId: 'test-chat-id' } } as FastifyRequest,
+        mockReply as unknown as FastifyReply,
+      );
+
+      expect(mockReply.code).toHaveBeenCalledWith(200);
+      expect(mockReply.send).toHaveBeenCalledWith({
+        chatName: 'New Chat',
+      });
+      expect(generateChatName).not.toHaveBeenCalled();
+      expect(updateChatName).not.toHaveBeenCalled();
+    });
+
+    it('should filter out invalid message objects without role property', async () => {
+      (getConversation as jest.Mock).mockResolvedValue({
+        chatHistory: [
+          { role: 'user', content: 'Valid message' },
+          { content: 'Invalid message object' },
+          { type: 'reasoning', text: 'Some reasoning' },
+          { role: 'user', content: 'Another valid message' },
+          { role: 'assistant', content: 'Response' },
+        ],
+      });
+      (generateChatName as jest.Mock).mockResolvedValue('Filtered Name');
+
+      await postHandler(
+        { ...mockRequest, body: { chatId: 'test-chat-id' } } as FastifyRequest,
+        mockReply as unknown as FastifyReply,
+      );
+
+      expect(mockReply.code).toHaveBeenCalledWith(200);
+      expect(mockReply.send).toHaveBeenCalledWith({
+        chatName: 'Filtered Name',
+      });
+      expect(generateChatName).toHaveBeenCalledWith(
+        [
+          { role: 'user', content: 'Valid message' },
+          { role: 'user', content: 'Another valid message' },
+        ],
+        'test-project-id',
+      );
+    });
+
+    it('should call generateChatName with all user messages (filtered)', async () => {
+      const mockChatHistory = [
+        { role: 'user', content: 'First question' },
+        { role: 'assistant', content: 'First answer' },
+        { role: 'user', content: 'Second question' },
+        { role: 'assistant', content: 'Second answer' },
+        { role: 'user', content: 'Third question' },
+      ];
+
+      (getConversation as jest.Mock).mockResolvedValue({
+        chatHistory: mockChatHistory,
+      });
+      (generateChatName as jest.Mock).mockResolvedValue('Multi-Question Chat');
+
+      await postHandler(
+        { ...mockRequest, body: { chatId: 'test-chat-id' } } as FastifyRequest,
+        mockReply as unknown as FastifyReply,
+      );
+
+      expect(generateChatName).toHaveBeenCalledWith(
+        [
+          { role: 'user', content: 'First question' },
+          { role: 'user', content: 'Second question' },
+          { role: 'user', content: 'Third question' },
+        ],
+        'test-project-id',
+      );
+      expect(mockReply.code).toHaveBeenCalledWith(200);
+      expect(mockReply.send).toHaveBeenCalledWith({
+        chatName: 'Multi-Question Chat',
+      });
     });
 
-    it('should return "New Chat" if LLM returns empty', async () => {
+    it('should return "New Chat" if LLM returns empty/whitespace', async () => {
       (getConversation as jest.Mock).mockResolvedValue({
         chatHistory: [
           { role: 'user', content: 'Hello?' },
@@ -405,7 +507,32 @@ describe('AI MCP Chat Controller - Tool Service Interactions', () => {
       );
 
       expect(mockReply.code).toHaveBeenCalledWith(200);
-      expect(mockReply.send).toHaveBeenCalledWith({ chatName: 'New Chat' });
+      expect(mockReply.send).toHaveBeenCalledWith({
+        chatName: 'New Chat',
+      });
+      expect(updateChatName).toHaveBeenCalledWith(
+        'test-chat-id',
+        'test-user-id',
+        'test-project-id',
+        'New Chat',
+      );
+    });
+
+    it('should return "New Chat" if LLM returns empty string', async () => {
+      (getConversation as jest.Mock).mockResolvedValue({
+        chatHistory: [{ role: 'user', content: 'Test question' }],
+      });
+      (generateChatName as jest.Mock).mockResolvedValue('');
+
+      await postHandler(
+        { ...mockRequest, body: { chatId: 'test-chat-id' } } as FastifyRequest,
+        mockReply as unknown as FastifyReply,
+      );
+
+      expect(mockReply.code).toHaveBeenCalledWith(200);
+      expect(mockReply.send).toHaveBeenCalledWith({
+        chatName: 'New Chat',
+      });
     });
 
     it('should persist chatName in chat context', async () => {
@@ -418,17 +545,22 @@ describe('AI MCP Chat Controller - Tool Service Interactions', () => {
       (generateChatName as jest.Mock).mockResolvedValue(
         'OpenOps Platform Overview',
       );
-      const postHandler = handlers['/chat-name'];
+
       await postHandler(
         { ...mockRequest, body: { chatId: 'test-chat-id' } } as FastifyRequest,
         mockReply as unknown as FastifyReply,
       );
+
       expect(updateChatName).toHaveBeenCalledWith(
         'test-chat-id',
         'test-user-id',
         'test-project-id',
         'OpenOps Platform Overview',
       );
+      expect(mockReply.code).toHaveBeenCalledWith(200);
+      expect(mockReply.send).toHaveBeenCalledWith({
+        chatName: 'OpenOps Platform Overview',
+      });
     });
 
     it('should handle errors gracefully', async () => {
@@ -444,6 +576,25 @@ describe('AI MCP Chat Controller - Tool Service Interactions', () => {
         expect.objectContaining({ message: 'Internal server error' }),
       );
     });
+
+    it('should handle generateChatName errors gracefully', async () => {
+      (getConversation as jest.Mock).mockResolvedValue({
+        chatHistory: [{ role: 'user', content: 'Test question' }],
+      });
+      (generateChatName as jest.Mock).mockRejectedValue(
+        new Error('LLM API error'),
+      );
+
+      await postHandler(
+        { ...mockRequest, body: { chatId: 'test-chat-id' } } as FastifyRequest,
+        mockReply as unknown as FastifyReply,
+      );
+
+      expect(mockReply.code).toHaveBeenCalledWith(500);
+      expect(mockReply.send).toHaveBeenCalledWith(
+        expect.objectContaining({ message: 'Internal server error' }),
+      );
+    });
   });
 
   describe('GET /all-chats (list all chats)', () => {