feat: add message retry and regenerate functionality

.changeset/retry-regenerate-messages.md

@@ -0,0 +1,7 @@
+---
+'@chatcops/core': minor
+'@chatcops/server': minor
+'@chatcops/widget': minor
+---
+
+Add retry and regenerate support for widget conversations, including assistant message regeneration, retryable error bubbles, and server-side conversation updates for regenerate requests.

packages/core/src/conversation/manager.ts

@@ -47,6 +47,15 @@ export class ConversationManager {
     return conversation?.messages ?? [];
   }
 
+  async removeMessage(conversationId: string, messageId: string): Promise<void> {
+    const conversation = await this.store.get(conversationId);
+    if (!conversation) return;
+
+    conversation.messages = conversation.messages.filter((message) => message.id !== messageId);
+    conversation.updatedAt = Date.now();
+    await this.store.save(conversation);
+  }
+
   async deleteConversation(id: string): Promise<void> {
     await this.store.delete(id);
   }

packages/core/tests/conversation/manager.test.ts

@@ -89,4 +89,18 @@ describe('ConversationManager', () => {
     const messages = await manager.getMessages('nope');
     expect(messages).toHaveLength(0);
   });
+
+  it('removes a message by id', async () => {
+    const manager = new ConversationManager();
+    const userMessage = makeMessage('user', 'Hello');
+    const assistantMessage = makeMessage('assistant', 'Hi there!');
+
+    await manager.addMessage('conv-remove', userMessage);
+    await manager.addMessage('conv-remove', assistantMessage);
+    await manager.removeMessage('conv-remove', assistantMessage.id);
+
+    const messages = await manager.getMessages('conv-remove');
+    expect(messages).toHaveLength(1);
+    expect(messages[0].id).toBe(userMessage.id);
+  });
 });

packages/server/src/config.ts

@@ -17,6 +17,8 @@ export interface ChatCopsServerConfig {
 export const chatRequestSchema = z.object({
   conversationId: z.string().min(1).max(128),
   message: z.string().min(1).max(10000),
+  messageId: z.string().min(1).max(128).optional(),
+  regenerate: z.boolean().optional(),
   pageContext: z.object({
     url: z.string().url(),
     title: z.string().max(500),

packages/server/src/handler.ts

@@ -46,22 +46,38 @@ export function createChatHandler(config: ChatCopsServerConfig) {
     }
 
     // Get or create conversation
-    const conversation = await conversations.getOrCreate(req.conversationId);
+    await conversations.getOrCreate(req.conversationId);
+
+    if (req.regenerate) {
+      const existingMessages = await conversations.getMessages(req.conversationId);
+      const lastAssistant = [...existingMessages].reverse().find((message) => message.role === 'assistant');
+      if (lastAssistant) {
+        await conversations.removeMessage(req.conversationId, lastAssistant.id);
+      }
+    }
+
+    const conversationMessages = await conversations.getMessages(req.conversationId);
 
     // Track analytics
-    if (analytics && conversation.messages.length === 0) {
+    if (analytics && conversationMessages.length === 0) {
       analytics.track('conversation:started', { conversationId: req.conversationId });
     }
     analytics?.track('message:sent', { conversationId: req.conversationId });
 
-    // Add user message
-    const userMessage: ChatMessage = {
-      id: crypto.randomUUID(),
-      role: 'user',
-      content: req.message,
-      timestamp: Date.now(),
-    };
-    await conversations.addMessage(req.conversationId, userMessage);
+    // Add user message unless this is a regenerate request or a retry of the same message
+    const hasExistingUserMessage = req.messageId
+      ? conversationMessages.some((message) => message.id === req.messageId)
+      : false;
+
+    if (!req.regenerate && !hasExistingUserMessage) {
+      const userMessage: ChatMessage = {
+        id: req.messageId ?? crypto.randomUUID(),
+        role: 'user',
+        content: req.message,
+        timestamp: Date.now(),
+      };
+      await conversations.addMessage(req.conversationId, userMessage);
+    }
 
     // Build system prompt
     let systemPrompt = config.systemPrompt;

packages/server/tests/handler.test.ts

@@ -1,23 +1,24 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 vi.mock('@chatcops/core', () => {
+  type ChatMessage = {
+    id: string;
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    timestamp: number;
+    metadata?: Record<string, unknown>;
+  };
+
+  type Conversation = {
+    id: string;
+    messages: ChatMessage[];
+    metadata?: Record<string, unknown>;
+    createdAt: number;
+    updatedAt: number;
+  };
+
   class ConversationManager {
-    private readonly conversations = new Map<
-      string,
-      {
-        id: string;
-        messages: Array<{
-          id: string;
-          role: 'user' | 'assistant' | 'system';
-          content: string;
-          timestamp: number;
-          metadata?: Record<string, unknown>;
-        }>;
-        metadata?: Record<string, unknown>;
-        createdAt: number;
-        updatedAt: number;
-      }
-    >();
+    private readonly conversations = new Map<string, Conversation>();
 
     async getOrCreate(id: string) {
       const existing = this.conversations.get(id);
@@ -26,7 +27,7 @@ vi.mock('@chatcops/core', () => {
       }
 
       const now = Date.now();
-      const conversation = {
+      const conversation: Conversation = {
         id,
         messages: [],
         createdAt: now,
@@ -36,22 +37,23 @@ vi.mock('@chatcops/core', () => {
       return conversation;
     }
 
-    async addMessage(conversationId: string, message: {
-      id: string;
-      role: 'user' | 'assistant' | 'system';
-      content: string;
-      timestamp: number;
-      metadata?: Record<string, unknown>;
-    }) {
+    async addMessage(conversationId: string, message: ChatMessage) {
       const conversation = await this.getOrCreate(conversationId);
       conversation.messages.push(message);
       conversation.updatedAt = Date.now();
+      return conversation;
     }
 
     async getMessages(conversationId: string) {
       const conversation = await this.getOrCreate(conversationId);
       return [...conversation.messages];
     }
+
+    async removeMessage(conversationId: string, messageId: string) {
+      const conversation = await this.getOrCreate(conversationId);
+      conversation.messages = conversation.messages.filter((message) => message.id !== messageId);
+      conversation.updatedAt = Date.now();
+    }
   }
 
   class AnalyticsCollector {
@@ -333,6 +335,54 @@ describe('createChatHandler', () => {
       },
     });
   });
+
+  it('removes the previous assistant message before regenerating', async () => {
+    const receivedMessages: Array<Array<{ role: string; content: string }>> = [];
+
+    mockedCreateProvider.mockResolvedValue({
+      name: 'test-provider',
+      async *chat(params) {
+        receivedMessages.push(
+          params.messages.map((message) => ({
+            role: message.role,
+            content: message.content,
+          }))
+        );
+        yield receivedMessages.length === 1 ? 'First reply' : 'Regenerated reply';
+      },
+      async chatSync() {
+        return '';
+      },
+    });
+
+    const { handleChat } = createChatHandler({
+      provider: { type: 'claude', apiKey: 'test-key' },
+      systemPrompt: 'Test',
+      cors: '*',
+    });
+
+    for await (const _chunk of handleChat({
+      conversationId: 'conv-regenerate',
+      message: 'Hello there',
+      messageId: 'user-1',
+    })) {
+      // Drain initial response.
+    }
+
+    for await (const _chunk of handleChat({
+      conversationId: 'conv-regenerate',
+      message: 'Hello there',
+      messageId: 'user-1',
+      regenerate: true,
+    })) {
+      // Drain regenerated response.
+    }
+
+    expect(receivedMessages).toEqual([
+      [{ role: 'user', content: 'Hello there' }],
+      [{ role: 'user', content: 'Hello there' }],
+    ]);
+  });
 });
 
 describe('chatRequestSchema', () => {
@@ -358,6 +408,21 @@ describe('chatRequestSchema', () => {
     expect(result.success).toBe(true);
   });
 
+  it('accepts regenerate metadata', () => {
+    const result = chatRequestSchema.safeParse({
+      conversationId: 'conv-1',
+      message: 'Hello',
+      messageId: 'msg-1',
+      regenerate: true,
+    });
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.messageId).toBe('msg-1');
+      expect(result.data.regenerate).toBe(true);
+    }
+  });
+
   it('rejects empty conversationId', () => {
     const result = chatRequestSchema.safeParse({
       conversationId: '',
@@ -403,6 +468,7 @@ describe('chatRequestSchema', () => {
     if (result.success) {
       expect(result.data.pageContext).toBeUndefined();
       expect(result.data.locale).toBeUndefined();
+      expect(result.data.regenerate).toBeUndefined();
     }
   });
 });

packages/widget/src/api/types.ts

@@ -1,6 +1,8 @@
 export interface WidgetChatRequest {
   conversationId: string;
   message: string;
+  messageId?: string;
+  regenerate?: boolean;
   pageContext?: {
     url: string;
     title: string;