msg versions

server/chatStream.js

@@ -130,33 +130,52 @@ export async function streamChat(ws, {
     // Otherwise extract text
     const hasImages = userMessage.some(item => item.type === 'image_url');
     if (hasImages) {
-      normalizedUserMessage = userMessage;
+      // Keep the full array - may need to add placeholder text if no text items
+      const textItems = userMessage.filter(item => item.type === 'text' && item.text?.trim());
+      if (textItems.length === 0) {
+        // Add a text placeholder to accompany images
+        normalizedUserMessage = [
+          { type: 'text', text: '[Image(s) attached]' },
+          ...userMessage.filter(item => item.type === 'image_url'),
+        ];
+      } else {
+        normalizedUserMessage = userMessage;
+      }
     } else {
-      normalizedUserMessage = userMessage.filter(b => b.type === "text").map(b => b.text).join("\n") || "";
+      // Text only - extract
+      normalizedUserMessage = userMessage.filter(b => b.type === "text").map(b => b.text).join("\n").trim() || "";
     }
   }
 
   // Build messages array: only include user message if it's provided
+  const hasUserMessage = userMessage !== undefined && userMessage !== null && userMessage !== '' && 
+    !(Array.isArray(userMessage) && userMessage.length === 0);
   const messages = [
     { role: "system", content: SYSTEM_PROMPT },
     ...history.map(normalizeMessage).filter(Boolean),
   ];
   
   // Add user message only if content was provided (not for edit-only requests)
-  if (userMessage !== undefined && userMessage !== null && userMessage !== '') {
+  if (hasUserMessage) {
     messages.push({ role: "user", content: normalizedUserMessage });
   }
 
   // Validate messages before API call
+  const invalidMessages = [];
   for (let i = 0; i < messages.length; i++) {
     const msg = messages[i];
     if (msg.role !== "assistant" || !msg.tool_calls) {
       if (typeof msg.content !== "string" && !Array.isArray(msg.content)) {
-        console.error(`Message ${i} has invalid content:`, msg);
-        throw new Error(`Message ${i} missing or invalid content property`);
+        invalidMessages.push({index: i, role: msg.role, contentType: typeof msg.content});
       }
     }
   }
+  
+  if (invalidMessages.length > 0) {
+    const details = invalidMessages.map(m => `${m.index}:${m.role}(${m.contentType})`).join(',');
+    console.error(`streamChat: Invalid message content types: ${details}`);
+    throw new Error(`Message validation failed: invalid content types [${details}]`);
+  }
 
   try {
     const stream = await client.chat.completions.create({
@@ -179,7 +198,7 @@ export async function streamChat(ws, {
       ];
       
       // Include user message in follow-up only if it was in the original request
-      if (userMessage !== undefined && userMessage !== null && userMessage !== '') {
+      if (hasUserMessage) {
         followUpMessages.push({ role: "user", content: normalizedUserMessage });
       }
       

server/wsHandler.js

@@ -216,7 +216,9 @@ const handlers = {
         const finalText = text || fullText;
         
         // Only create user entry if content was actually provided
-        const userEntry = (content !== undefined && content !== null && content !== '')
+        const hasContent = content !== undefined && content !== null && content !== '' && 
+          !(Array.isArray(content) && content.length === 0);
+        const userEntry = hasContent
           ? buildEntry('user', content)
           : null;
 
@@ -263,7 +265,11 @@ const handlers = {
         
         safeSend(ws, { type: aborted ? 'chat:aborted' : 'chat:done', sessionId, name: newName, history: extractFlatHistory(newRootMessage) });
       },
-      onError(err) { activeStreams.delete(ws); safeSend(ws, { type: 'chat:error', error: String(err), sessionId }); },
+      onError(err) { 
+        activeStreams.delete(ws);
+        console.error('streamChat error:', err);
+        safeSend(ws, { type: 'chat:error', error: String(err), sessionId }); 
+      },
     });
   },
 
@@ -274,14 +280,18 @@ const handlers = {
     const session = client.userId
       ? sessionStore.getUserSession(client.userId, sessionId)
       : sessionStore.getTempSession(client.tempId, sessionId);
-    if (!session) return;
+    if (!session) return safeSend(ws, { type: 'error', message: 'Session not found' });
     
     const rootMessage = session.history?.[0];
-    if (!rootMessage) return;
+    if (!rootMessage) return safeSend(ws, { type: 'error', message: 'No history' });
     
     const flatHistory = extractFlatHistory(rootMessage);
     const targetMsg = flatHistory[messageIndex];
-    if (!targetMsg) return;
+    if (!targetMsg) {
+      console.error(`chat:editMessage: Message at index ${messageIndex} not found. History length: ${flatHistory.length}`);
+      return safeSend(ws, { type: 'error', message: 'Message not found' });
+    }
+    console.log(`chat:editMessage: Editing message ${targetMsg.id} at index ${messageIndex}`);
     
     // Find the target message in the tree and add new version
     const newRoot = validateAndRepairTree(JSON.parse(JSON.stringify(rootMessage)));
@@ -312,6 +322,13 @@ const handlers = {
     // Send back the updated message with its ID and the full flat history
     const updatedFlatHistory = extractFlatHistory(newRoot);
     const updatedTargetMsg = updatedFlatHistory[messageIndex];
+    
+    if (!updatedTargetMsg) {
+      console.error(`chat:editMessage: Updated message not found at index ${messageIndex}. Updated history length: ${updatedFlatHistory.length}`);
+      return safeSend(ws, { type: 'error', message: 'Failed to apply edit - message lost' });
+    }
+    
+    console.log(`chat:editMessage: Edit complete. Message ${updatedTargetMsg.id} now has ${updatedTargetMsg.versions?.length ?? 0} versions`);
     safeSend(ws, { type: 'chat:messageEdited', sessionId, messageId: targetMsg.id, messageIndex, message: updatedTargetMsg, history: updatedFlatHistory });
   },
 
@@ -441,7 +458,6 @@ function extractFlatHistory(rootMessage) {
   // Helper to ensure message has valid content
   const ensureValidContent = (msg) => {
     if (msg.content === undefined || msg.content === null) {
-      console.warn(`Message ${msg.id} has missing content, defaulting to empty string`);
       msg.content = '';
     }
     return msg;
@@ -449,6 +465,17 @@ function extractFlatHistory(rootMessage) {
   
   const history = [ensureValidContent(rootMessage)];
   const currentVerIdx = rootMessage.currentVersionIdx ?? 0;
+  
+  if (!Array.isArray(rootMessage.versions)) {
+    console.warn(`extractFlatHistory: Root message ${rootMessage.id} missing versions array`);
+    return history;
+  }
+  
+  if (currentVerIdx >= rootMessage.versions.length) {
+    console.warn(`extractFlatHistory: Root message currentVersionIdx ${currentVerIdx} out of bounds (${rootMessage.versions.length} versions)`);
+    return history;
+  }
+  
   const currentTail = rootMessage.versions[currentVerIdx]?.tail;
   
   if (currentTail && Array.isArray(currentTail)) {