Fix Chat History persistence across all conversation flows

- Add message saving to /api/brief/parse endpoint (user message + parsing response)
- Add confirmation message saving to /api/brief/confirm endpoint
- Add message saving to /api/generate endpoint (request + generated content)
- Update frontend API to pass conversationId and userId to parseBrief
- Update streamGenerateContent to accept and send userId
- Fix assistant response saving condition (requires_user_input OR is_final)
- Add delete_conversation method to cosmos_service
- Update ChatHistory component with currentMessages prop and refresh trigger

Author: hunterjam

content-gen/src/app.py

@@ -95,22 +95,23 @@ async def generate():
             ):
                 yield f"data: {json.dumps(response)}\n\n"
 
-                # Try to save assistant responses
-                if response.get("is_final"):
-                    try:
-                        cosmos_service = await get_cosmos_service()
-                        await cosmos_service.add_message_to_conversation(
-                            conversation_id=conversation_id,
-                            user_id=user_id,
-                            message={
-                                "role": "assistant",
-                                "content": response.get("content", ""),
-                                "agent": response.get("agent", ""),
-                                "timestamp": datetime.now(timezone.utc).isoformat()
-                            }
-                        )
-                    except Exception as e:
-                        logger.warning(f"Failed to save response to CosmosDB: {e}")
+                # Save assistant responses when final OR when requiring user input
+                if response.get("is_final") or response.get("requires_user_input"):
+                    if response.get("content"):
+                        try:
+                            cosmos_service = await get_cosmos_service()
+                            await cosmos_service.add_message_to_conversation(
+                                conversation_id=conversation_id,
+                                user_id=user_id,
+                                message={
+                                    "role": "assistant",
+                                    "content": response.get("content", ""),
+                                    "agent": response.get("agent", ""),
+                                    "timestamp": datetime.now(timezone.utc).isoformat()
+                                }
+                            )
+                        except Exception as e:
+                            logger.warning(f"Failed to save response to CosmosDB: {e}")
         except Exception as e:
             logger.exception(f"Error in orchestrator: {e}")
             yield f"data: {json.dumps({'type': 'error', 'content': str(e), 'is_final': True})}\n\n"
@@ -136,24 +137,60 @@ async def parse_brief():
     
     Request body:
     {
-        "brief_text": "Free-form creative brief text"
+        "brief_text": "Free-form creative brief text",
+        "conversation_id": "optional-uuid",
+        "user_id": "user identifier"
     }
     
     Returns:
         Structured CreativeBrief JSON for user confirmation.
     """
     data = await request.get_json()
     brief_text = data.get("brief_text", "")
+    conversation_id = data.get("conversation_id") or str(uuid.uuid4())
+    user_id = data.get("user_id", "anonymous")
 
     if not brief_text:
         return jsonify({"error": "Brief text is required"}), 400
 
+    # Save the user's brief text as a message to CosmosDB
+    try:
+        cosmos_service = await get_cosmos_service()
+        await cosmos_service.add_message_to_conversation(
+            conversation_id=conversation_id,
+            user_id=user_id,
+            message={
+                "role": "user",
+                "content": brief_text,
+                "timestamp": datetime.now(timezone.utc).isoformat()
+            }
+        )
+    except Exception as e:
+        logger.warning(f"Failed to save brief message to CosmosDB: {e}")
+    
     orchestrator = get_orchestrator()
     parsed_brief = await orchestrator.parse_brief(brief_text)
 
+    # Save the assistant's parsing response
+    try:
+        cosmos_service = await get_cosmos_service()
+        await cosmos_service.add_message_to_conversation(
+            conversation_id=conversation_id,
+            user_id=user_id,
+            message={
+                "role": "assistant",
+                "content": "I've parsed your creative brief. Please review and confirm the details before we proceed.",
+                "agent": "PlanningAgent",
+                "timestamp": datetime.now(timezone.utc).isoformat()
+            }
+        )
+    except Exception as e:
+        logger.warning(f"Failed to save parsing response to CosmosDB: {e}")
+    
     return jsonify({
         "brief": parsed_brief.model_dump(),
         "requires_confirmation": True,
+        "conversation_id": conversation_id,
         "message": "Please review and confirm the parsed creative brief"
     })
 
@@ -183,13 +220,26 @@ async def confirm_brief():
     except Exception as e:
         return jsonify({"error": f"Invalid brief format: {str(e)}"}), 400
 
-    # Try to save the confirmed brief to CosmosDB, but don't fail if unavailable
+    # Try to save the confirmed brief to CosmosDB, preserving existing messages
     try:
         cosmos_service = await get_cosmos_service()
+        
+        # Get existing conversation to preserve messages
+        existing = await cosmos_service.get_conversation(conversation_id, user_id)
+        existing_messages = existing.get("messages", []) if existing else []
+        
+        # Add confirmation message
+        existing_messages.append({
+            "role": "assistant",
+            "content": "Great! Your creative brief has been confirmed. Now you can select products to feature and generate content.",
+            "agent": "TriageAgent",
+            "timestamp": datetime.now(timezone.utc).isoformat()
+        })
+        
         await cosmos_service.save_conversation(
             conversation_id=conversation_id,
             user_id=user_id,
-            messages=[],
+            messages=existing_messages,
             brief=brief,
             metadata={"status": "brief_confirmed"}
         )
@@ -227,12 +277,29 @@ async def generate_content():
     products_data = data.get("products", [])
     generate_images = data.get("generate_images", True)
     conversation_id = data.get("conversation_id") or str(uuid.uuid4())
+    user_id = data.get("user_id", "anonymous")
 
     try:
         brief = CreativeBrief(**brief_data)
     except Exception as e:
         return jsonify({"error": f"Invalid brief format: {str(e)}"}), 400
 
+    # Save user request for content generation
+    try:
+        cosmos_service = await get_cosmos_service()
+        product_names = [p.get("product_name", "product") for p in products_data[:3]]
+        await cosmos_service.add_message_to_conversation(
+            conversation_id=conversation_id,
+            user_id=user_id,
+            message={
+                "role": "user",
+                "content": f"Generate content for: {', '.join(product_names) if product_names else 'the campaign'}",
+                "timestamp": datetime.now(timezone.utc).isoformat()
+            }
+        )
+    except Exception as e:
+        logger.warning(f"Failed to save generation request to CosmosDB: {e}")
+    
     orchestrator = get_orchestrator()
 
     async def generate():
@@ -256,6 +323,24 @@ async def generate():
             except Exception as e:
                 logger.warning(f"Failed to save image to blob storage: {e}")
 
+            # Save generated content to conversation
+            try:
+                cosmos_service = await get_cosmos_service()
+                text_content = response.get("text_content", {})
+                headline = text_content.get("headline", "") if isinstance(text_content, dict) else ""
+                await cosmos_service.add_message_to_conversation(
+                    conversation_id=conversation_id,
+                    user_id=user_id,
+                    message={
+                        "role": "assistant",
+                        "content": f"Content generated successfully! {f'Headline: "{headline}"' if headline else ''}",
+                        "agent": "ContentAgent",
+                        "timestamp": datetime.now(timezone.utc).isoformat()
+                    }
+                )
+            except Exception as e:
+                logger.warning(f"Failed to save generated content to CosmosDB: {e}")
+            
             # Format response to match what frontend expects
             yield f"data: {json.dumps({'type': 'agent_response', 'content': json.dumps(response), 'is_final': True})}\n\n"
         except Exception as e:
@@ -441,6 +526,28 @@ async def get_conversation(conversation_id: str):
     return jsonify(conversation)
 
 
+@app.route("/api/conversations/<conversation_id>", methods=["DELETE"])
+async def delete_conversation(conversation_id: str):
+    """
+    Delete a specific conversation.
+    
+    Query params:
+        user_id: User identifier (required)
+    """
+    user_id = request.args.get("user_id")
+    
+    if not user_id:
+        return jsonify({"error": "user_id is required"}), 400
+    
+    try:
+        cosmos_service = await get_cosmos_service()
+        await cosmos_service.delete_conversation(conversation_id, user_id)
+        return jsonify({"success": True, "message": "Conversation deleted"})
+    except Exception as e:
+        logger.warning(f"Failed to delete conversation: {e}")
+        return jsonify({"error": "Failed to delete conversation"}), 500
+
+
 # ==================== Brand Guidelines Endpoints ====================
 
 @app.route("/api/brand-guidelines", methods=["GET"])

content-gen/src/backend/services/cosmos_service.py

@@ -325,20 +325,20 @@ async def get_user_conversations(
         limit: int = 20
     ) -> List[dict]:
         """
-        Get all conversations for a user.
+        Get all conversations for a user with summary data.
         
         Args:
             user_id: User ID
             limit: Maximum number of conversations
         
         Returns:
-            List of conversations
+            List of conversation summaries
         """
         await self.initialize()
 
+        # Get conversations with messages to extract title and last message
         query = """
-            SELECT TOP @limit c.id, c.user_id, c.updated_at, 
-                   ARRAY_LENGTH(c.messages) as message_count
+            SELECT TOP @limit c.id, c.user_id, c.updated_at, c.messages, c.brief
             FROM c 
             WHERE c.user_id = @user_id
             ORDER BY c.updated_at DESC
@@ -353,9 +353,61 @@ async def get_user_conversations(
             query=query,
             parameters=params
         ):
-            conversations.append(item)
+            messages = item.get("messages", [])
+            brief = item.get("brief", {})
+            
+            # Extract title from brief overview or first user message
+            title = "Untitled Conversation"
+            if brief and brief.get("overview"):
+                title = brief["overview"][:50]
+            elif messages:
+                for msg in messages:
+                    if msg.get("role") == "user":
+                        title = msg.get("content", "")[:50]
+                        break
+            
+            # Get last message preview
+            last_message = ""
+            if messages:
+                last_msg = messages[-1]
+                last_message = last_msg.get("content", "")[:100]
+            
+            conversations.append({
+                "id": item["id"],
+                "title": title,
+                "lastMessage": last_message,
+                "timestamp": item.get("updated_at", ""),
+                "messageCount": len(messages)
+            })
 
         return conversations
+    
+    async def delete_conversation(
+        self,
+        conversation_id: str,
+        user_id: str
+    ) -> bool:
+        """
+        Delete a conversation.
+        
+        Args:
+            conversation_id: Unique conversation identifier
+            user_id: User ID for partition key
+        
+        Returns:
+            True if deleted successfully
+        """
+        await self.initialize()
+        
+        try:
+            await self._conversations_container.delete_item(
+                item=conversation_id,
+                partition_key=user_id
+            )
+            return True
+        except Exception as e:
+            logger.warning(f"Failed to delete conversation {conversation_id}: {e}")
+            raise
 
 
 # Singleton instance

content-gen/src/frontend/src/App.tsx

@@ -33,15 +33,26 @@ function App() {
   // Generated content
   const [generatedContent, setGeneratedContent] = useState<GeneratedContent | null>(null);
 
+  // Trigger for refreshing chat history
+  const [historyRefreshTrigger, setHistoryRefreshTrigger] = useState(0);
+
   // Handle selecting a conversation from history
   const handleSelectConversation = useCallback(async (selectedConversationId: string) => {
     setIsLoading(true);
     try {
-      const response = await fetch(`/api/conversations/${selectedConversationId}`);
+      const response = await fetch(`/api/conversations/${selectedConversationId}?user_id=${encodeURIComponent(userId)}`);
       if (response.ok) {
         const data = await response.json();
         setConversationId(selectedConversationId);
-        setMessages(data.messages || []);
+        // Map messages to ChatMessage format
+        const loadedMessages: ChatMessage[] = (data.messages || []).map((msg: { role: string; content: string; timestamp?: string; agent?: string }, index: number) => ({
+          id: `${selectedConversationId}-${index}`,
+          role: msg.role as 'user' | 'assistant',
+          content: msg.content,
+          timestamp: msg.timestamp || new Date().toISOString(),
+          agent: msg.agent,
+        }));
+        setMessages(loadedMessages);
         setPendingBrief(null);
         setConfirmedBrief(data.brief || null);
         setGeneratedContent(null);
@@ -52,7 +63,7 @@ function App() {
     } finally {
       setIsLoading(false);
     }
-  }, []);
+  }, [userId]);
 
   // Handle starting a new conversation
   const handleNewConversation = useCallback(() => {
@@ -85,7 +96,7 @@ function App() {
 
       if (isBriefLike && !confirmedBrief) {
         // Parse as a creative brief
-        const parsed = await parseBrief(content);
+        const parsed = await parseBrief(content, conversationId, userId);
         setPendingBrief(parsed.brief);
 
         const assistantMessage: ChatMessage = {
@@ -143,6 +154,8 @@ function App() {
       setMessages(prev => [...prev, errorMessage]);
     } finally {
       setIsLoading(false);
+      // Trigger refresh of chat history after message is sent
+      setHistoryRefreshTrigger(prev => prev + 1);
     }
   }, [conversationId, userId, confirmedBrief]);
 
@@ -188,7 +201,8 @@ function App() {
         confirmedBrief,
         selectedProducts,
         true,
-        conversationId
+        conversationId,
+        userId
       )) {
         if (response.is_final && response.type !== 'error') {
           try {
@@ -292,8 +306,11 @@ function App() {
         <div className="history-panel">
           <ChatHistory
             currentConversationId={conversationId}
+            userId={userId}
+            currentMessages={messages}
             onSelectConversation={handleSelectConversation}
             onNewConversation={handleNewConversation}
+            refreshTrigger={historyRefreshTrigger}
           />
         </div>