@peopl-health/nexus 2.4.9 → 2.4.10

package/lib/controllers/conversationController.js

@@ -1,10 +1,11 @@
 const mongoose = require('mongoose');
-const { fetchConversationData, processConversations } = require('../services/conversationService');
-const { sendMessage } = require('../core/NexusMessaging');
-const { Thread } = require('../models/threadModel');
 const llmConfig = require('../config/llmConfig');
 const { Historial_Clinico_ID } = require('../config/airtableConfig');
+const { Thread } = require('../models/threadModel');
+const { withThreadRecovery } = require('../helpers/threadRecoveryHelper');
 const { getRecordByFilter } = require('../services/airtableService');
+const { fetchConversationData, processConversations } = require('../services/conversationService');
+const { sendMessage } = require('../core/NexusMessaging');
 const { logger } = require('../utils/logger');
 
 const Message = mongoose.models.Message;
@@ -649,7 +650,7 @@ const getOpenAIThreadMessagesController = async (req, res) => {
       });
     }
     
-    const thread = await Thread.findOne({ 
+    let thread = await Thread.findOne({ 
       code: phoneNumber, 
       active: true 
     }).sort({ createdAt: -1 });
@@ -662,7 +663,7 @@ const getOpenAIThreadMessagesController = async (req, res) => {
       });
     }
     
-    const conversationId = thread.conversation_id;
+    let conversationId = thread.conversation_id;
     logger.info('Thread found - Conversation ID:', conversationId);
     
     const provider = llmConfig.getOpenAIProvider({ instantiate: true, variant });
@@ -683,8 +684,23 @@ const getOpenAIThreadMessagesController = async (req, res) => {
       logger.info('Including runId:', runId);
     }
     
+    let messages;
+    let threadRecreated = false;
+    
     logger.info('Calling listMessages with params:', queryParams);
-    const messages = await provider.listMessages(queryParams);
+    messages = await withThreadRecovery(
+      async (currentThread = thread) => {
+        if (currentThread !== thread) {
+          thread = currentThread;
+          conversationId = currentThread.getConversationId();
+          queryParams.threadId = conversationId;
+          threadRecreated = true;
+        }
+        return await provider.listMessages(queryParams);
+      },
+      thread,
+      variant
+    );
     
     logger.info(`Retrieved ${messages?.data?.length || 0} messages from OpenAI`);
     
@@ -696,6 +712,7 @@ const getOpenAIThreadMessagesController = async (req, res) => {
       assistantId: thread.assistant_id,
       messages: messages.data || messages,
       hasMore: messages.has_more || false,
+      threadRecreated,
       pagination: {
         limit: parseInt(limit),
         order

package/lib/helpers/assistantHelper.js

@@ -3,6 +3,7 @@ const llmConfig = require('../config/llmConfig.js');
 const { Thread } = require('../models/threadModel.js');
 const { createProvider } = require('../providers/createProvider.js');
 const { withTracing } = require('../utils/tracingDecorator');
+const { withThreadRecovery } = require('./threadRecoveryHelper');
 
 const { getRecordByFilter } = require('../services/airtableService.js');
 const { logger } = require('../utils/logger');
@@ -62,37 +63,43 @@ const runAssistantAndWait = async ({
     ? { ...conversationConfig, assistant }
     : conversationConfig;
 
-  let run = await provider.runConversation({
-    threadId: thread.getConversationId(),
-    assistantId: thread.getAssistantId(),
-    tools: tools.length > 0 ? tools : undefined,
-    ...runConfigWithAssistant,
-  });
-
-  const filter = thread.code ? { code: thread.code, active: true } : null;
-  if (filter) {
-    await Thread.updateOne(filter, { $set: { run_id: run.id } });
-  }
-
-  const maxRetries = polling?.maxRetries ?? DEFAULT_MAX_RETRIES;
-  let completed = false;
-
-  try {
-    logger.info('[runAssistantAndWait] Run started', { runId: run.id, threadId: thread.getConversationId(), assistantId: thread.getAssistantId() });
-    ({run, completed} = await provider.checkRunStatus(assistant, thread.getConversationId(), run.id, 0, maxRetries));
-  } finally {
-    if (filter) {
-      await Thread.updateOne(filter, { $set: { run_id: null } });
-    }
-  }
+  return await withThreadRecovery(
+    async (currentThread = thread) => {
+      let run = await provider.runConversation({
+        threadId: currentThread.getConversationId(),
+        assistantId: currentThread.getAssistantId(),
+        tools: tools.length > 0 ? tools : undefined,
+        ...runConfigWithAssistant,
+      });
+
+      const filter = currentThread.code ? { code: currentThread.code, active: true } : null;
+      if (filter) {
+        await Thread.updateOne(filter, { $set: { run_id: run.id } });
+      }
+
+      const maxRetries = polling?.maxRetries ?? DEFAULT_MAX_RETRIES;
+      let completed = false;
+
+      try {
+        logger.info('[runAssistantAndWait] Run started', { runId: run.id, threadId: currentThread.getConversationId(), assistantId: currentThread.getAssistantId() });
+        ({run, completed} = await provider.checkRunStatus(assistant, currentThread.getConversationId(), run.id, 0, maxRetries));
+      } finally {
+        if (filter) {
+          await Thread.updateOne(filter, { $set: { run_id: null } });
+        }
+      }
 
-  if (!completed) {
-    return { run: run, completed: false, output: '' };
-  }
+      if (!completed) {
+        return { run: run, completed: false, output: '' };
+      }
 
-  const output = await provider.getRunText({ threadId: thread.getConversationId(), runId: run.id, fallback: '' });
+      const output = await provider.getRunText({ threadId: currentThread.getConversationId(), runId: run.id, fallback: '' });
 
-  return { completed: true, output };
+      return { completed: true, output };
+    },
+    thread,
+    variant
+  );
 };
 
 const executeAssistantAttempt = async (thread, assistant, runConfig, attemptNumber) => {

package/lib/helpers/filesHelper.js

@@ -1,6 +1,7 @@
 const { PDFDocument } = require('pdf-lib');
 const { execFile } = require('child_process');
 const fs = require('fs').promises;
+const fsSync = require('fs');
 const path = require('path');
 const sharp = require('sharp');
 
@@ -9,11 +10,11 @@ const { Message } = require('../models/messageModel.js');
 const { sanitizeFilename } = require('../utils/sanitizer.js');
 const { logger } = require('../utils/logger');
 
-async function convertPdfToImages(pdfName) {
+async function convertPdfToImages(pdfName, existingPdfPath = null) {
   const outputDir = path.join(__dirname, 'assets', 'tmp');
   
   const sanitizedName = sanitizeFilename(pdfName);
-  const pdfPath = path.join(outputDir, `${sanitizedName}.pdf`);
+  const pdfPath = existingPdfPath || path.join(outputDir, `${sanitizedName}.pdf`);
   const outputPattern = path.join(outputDir, sanitizedName);
 
   await fs.mkdir(outputDir, { recursive: true });
@@ -22,22 +23,52 @@ async function convertPdfToImages(pdfName) {
     const args = ['-jpeg', pdfPath, outputPattern];
     logger.info('[convertPdfToImages] Running: pdftoppm', args.join(' '));
     
-    execFile('pdftoppm', args, (error, stdout, stderr) => {
+    const timeout = 30000;
+    let timedOut = false;
+    
+    const child = execFile('pdftoppm', args, { timeout, maxBuffer: 10 * 1024 * 1024 }, (error, stdout, stderr) => {
+      if (timedOut) {
+        return;
+      }
+      
       if (error) {
+        logger.error('[convertPdfToImages] Error details:', { 
+          error: error.message, 
+          stderr, 
+          pdfPath,
+          pdfExists: fsSync.existsSync(pdfPath),
+          killed: error.killed,
+          signal: error.signal
+        });
         return reject(new Error(`Error splitting PDF: ${stderr || error.message}`));
       }
 
-      fs.readdir(outputDir, (err, files) => {
-        if (err) {
-          return reject(new Error(`Error reading output directory: ${err.message}`));
-        }
+      logger.info('[convertPdfToImages] pdftoppm completed successfully');
+
+      fs.readdir(outputDir)
+        .then(files => {
+          const jpgFiles = files
+            .filter(file => file.startsWith(sanitizedName) && file.endsWith('.jpg'))
+            .map(file => path.join(outputDir, file));
+
+          logger.info(`[convertPdfToImages] Found ${jpgFiles.length} image files`);
+          resolve(jpgFiles);
+        })
+        .catch(err => {
+          logger.error('[convertPdfToImages] Error reading output directory:', { error: err.message });
+          reject(new Error(`Error reading output directory: ${err.message}`));
+        });
+    });
 
-        const jpgFiles = files
-          .filter(file => file.startsWith(sanitizedName) && file.endsWith('.jpg'))
-          .map(file => path.join(outputDir, file));
+    const timeoutId = setTimeout(() => {
+      timedOut = true;
+      child.kill('SIGTERM');
+      logger.error('[convertPdfToImages] Process timed out after 30 seconds', { pdfPath });
+      reject(new Error('PDF conversion timed out after 30 seconds'));
+    }, timeout);
 
-        resolve(jpgFiles);
-      });
+    child.on('exit', () => {
+      clearTimeout(timeoutId);
     });
   });
 }
@@ -130,44 +161,69 @@ const cleanupFiles = async (files) => {
 };
 
 async function downloadMediaAndCreateFile(code, reply) {
-  const resultMedia = await Message.findOne({
-    message_id: reply.message_id,
-    timestamp: reply.timestamp,
-    media: { $ne: null }
-  });
+  try {
+    const resultMedia = await Message.findOne({
+      message_id: reply.message_id,
+      timestamp: reply.timestamp,
+      media: { $ne: null }
+    });
 
-  if (!resultMedia) return [];
+    if (!resultMedia) return [];
 
-  if (!resultMedia.media || !resultMedia.media.key) {
-    logger.info('[downloadMediaAndCreateFile] No valid media found for message:', reply.message_id);
-    return [];
-  }
+    if (!resultMedia.media || !resultMedia.media.key) {
+      logger.info('[downloadMediaAndCreateFile] No valid media found for message:', reply.message_id);
+      return [];
+    }
 
-  const { bucketName, key } = resultMedia.media;
-  if (!bucketName || !key) return [];
-  
-  const [subType, fileName] = key.split('/');
-  
-  const sanitizedCode = sanitizeFilename(code);
-  const sanitizedSubType = sanitizeFilename(subType);
-  const sanitizedFileName = sanitizeFilename(fileName);
-  
-  const sourceFile = `${sanitizedCode}-${sanitizedSubType}-${sanitizedFileName}`;
-  const downloadPath = path.join(__dirname, 'assets', 'tmp', sourceFile);
-  
-  await fs.mkdir(path.dirname(downloadPath), { recursive: true });
-  await downloadFileFromS3(bucketName, key, downloadPath);
+    const { bucketName, key } = resultMedia.media;
+    if (!bucketName || !key) return [];
+    
+    const [subType, fileName] = key.split('/');
+    
+    const sanitizedCode = sanitizeFilename(code, 20);
+    const sanitizedSubType = sanitizeFilename(subType, 10);
+    const sanitizedFileName = sanitizeFilename(fileName, 50);
+    
+    const sourceFile = `${sanitizedCode}-${sanitizedSubType}-${sanitizedFileName}`;
+    const downloadPath = path.join(__dirname, 'assets', 'tmp', sourceFile);
+    
+    logger.info('[downloadMediaAndCreateFile] Downloading file', { sourceFile, downloadPath, bucketName, key });
+    
+    await fs.mkdir(path.dirname(downloadPath), { recursive: true });
+    await downloadFileFromS3(bucketName, key, downloadPath);
 
-  const { name: baseName } = path.parse(sourceFile);
-  const fileNames = (subType === 'document' ||  subType === 'application')
-    ? await convertPdfToImages(baseName)
-    : [downloadPath];
+    const { name: baseName } = path.parse(sourceFile);
+    let fileNames = [];
+    
+    if (subType === 'document' || subType === 'application') {
+      try {
+        fileNames = await convertPdfToImages(baseName, downloadPath);
+        logger.info('[downloadMediaAndCreateFile] PDF converted successfully', { imageCount: fileNames.length });
+      } catch (conversionError) {
+        logger.error('[downloadMediaAndCreateFile] PDF conversion failed:', { 
+          error: conversionError.message,
+          sourceFile 
+        });
+        fileNames = [];
+      } finally {
+        try {
+          await fs.unlink(downloadPath);
+        } catch (unlinkError) {
+          logger.warn('[downloadMediaAndCreateFile] Failed to delete PDF:', { error: unlinkError.message });
+        }
+      }
+    } else {
+      fileNames = [downloadPath];
+    }
 
-  if (subType === 'document' ||  subType === 'application') {
-    await fs.unlink(downloadPath);
+    return fileNames;
+  } catch (error) {
+    logger.error('[downloadMediaAndCreateFile] Error processing media:', { 
+      error: error.message,
+      message_id: reply.message_id 
+    });
+    return [];
   }
-
-  return fileNames;
 }
 
 module.exports = {

package/lib/helpers/llmsHelper.js

@@ -1,7 +1,7 @@
 const llmConfig = require('../config/llmConfig.js');
 const { logger } = require('../utils/logger');
 const fs = require('fs');
-const mime = require('mime-types');
+const path = require('path');
 
 
 async function analyzeImage(imagePath, isSticker = false, contentType = null) {
@@ -30,14 +30,30 @@ async function analyzeImage(imagePath, isSticker = false, contentType = null) {
       };
     }
     
+    // Determine mime type from file extension
     let mimeType = contentType;
     if (!mimeType) {
-      if (imagePath.toLowerCase().endsWith('.webp')) {
-        mimeType = 'image/webp';
-      } else {
-        mimeType = mime.lookup(imagePath) || 'image/jpeg';
-      }
+      const ext = path.extname(imagePath).toLowerCase();
+      const mimeMap = {
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.png': 'image/png',
+        '.gif': 'image/gif',
+        '.webp': 'image/webp'
+      };
+      mimeType = mimeMap[ext] || 'image/jpeg'; // Default to jpeg for pdftoppm output
+    }
+    
+    // Validate that mime type is supported by Claude
+    const supportedMimeTypes = ['image/jpeg', 'image/png', 'image/gif', 'image/webp'];
+    if (!supportedMimeTypes.includes(mimeType)) {
+      logger.warn('[analyzeImage] Unsupported mime type, defaulting to image/jpeg:', { 
+        originalMimeType: mimeType, 
+        imagePath 
+      });
+      mimeType = 'image/jpeg';
     }
+    
     if (mimeType === 'image/vnd.wap.wbmp') {
       logger.info('Skipping image with MIME type:', mimeType);
       return {
@@ -49,6 +65,7 @@ async function analyzeImage(imagePath, isSticker = false, contentType = null) {
       };
     }
     // Read the image file and convert to base64
+    logger.info('[analyzeImage] Reading image file:', { imagePath: imagePath.split('/').pop() });
     const imageBuffer = await fs.promises.readFile(imagePath);
     const base64Image = imageBuffer.toString('base64');
 
@@ -77,6 +94,7 @@ async function analyzeImage(imagePath, isSticker = false, contentType = null) {
         },
       ],
     });
+    logger.info('[analyzeImage] Description received');
     const description = messageDescription.content[0].text;
 
     // For stickers, skip medical analysis and table extraction

package/lib/helpers/threadRecoveryHelper.js

@@ -0,0 +1,58 @@
+const { Thread } = require('../models/threadModel');
+const { createProvider } = require('../providers/createProvider');
+const { logger } = require('../utils/logger');
+
+const isThreadNotFoundError = (error) => {
+  return error?.status === 404 || 
+         error?.code === 'thread_not_found' ||
+         error?.code === 'invalid_thread_id' ||
+         (error?.message && (
+           error.message.includes('No thread found') ||
+           error.message.includes('thread does not exist') ||
+           error.message.includes('Invalid thread')
+         ));
+};
+
+const recreateThread = async (thread, variant = 'assistants') => {
+  const provider = createProvider({ variant });
+  const newConversation = await provider.createConversation({ 
+    metadata: { phoneNumber: thread.code, recreated: true } 
+  });
+  
+  await Thread.updateOne(
+    { code: thread.code, active: true },
+    { $set: { conversation_id: newConversation.id } }
+  );
+  
+  const updatedThread = await Thread.findOne({ code: thread.code, active: true });
+  logger.info('[threadRecovery] Thread recreated', { 
+    oldId: thread.conversation_id, 
+    newId: newConversation.id,
+    code: thread.code 
+  });
+  
+  return updatedThread;
+};
+
+const withThreadRecovery = async (operation, thread, variant = 'assistants') => {
+  try {
+    return await operation();
+  } catch (error) {
+    if (isThreadNotFoundError(error) && thread) {
+      logger.warn('[threadRecovery] Thread not found, recreating', { 
+        conversationId: thread.getConversationId?.() || thread.conversation_id,
+        code: thread.code 
+      });
+      
+      const recoveredThread = await recreateThread(thread, variant);
+      return await operation(recoveredThread);
+    }
+    throw error;
+  }
+};
+
+module.exports = {
+  isThreadNotFoundError,
+  recreateThread,
+  withThreadRecovery
+};

package/lib/services/assistantService.js

@@ -14,6 +14,7 @@ const { getThread, getThreadInfo } = require('../helpers/threadHelper.js');
 const { withTracing } = require('../utils/tracingDecorator.js');
 const { processThreadMessage } = require('../helpers/processHelper.js');
 const { getLastMessages, updateMessageRecord } = require('../helpers/messageHelper.js');
+const { withThreadRecovery } = require('../helpers/threadRecoveryHelper.js');
 const { combineImagesToPDF, cleanupFiles } = require('../helpers/filesHelper.js');
 const { logger } = require('../utils/logger');
 
@@ -137,13 +138,19 @@ const getAssistantById = (assistant_id, thread) => {
 const createAssistant = async (code, assistant_id, messages=[], force=false) => {
   const findThread = await Thread.findOne({ code: code });
   logger.info('[createAssistant] findThread', findThread);
-  if (findThread && findThread.getConversationId()) {
+  if (findThread && findThread.getConversationId() && !force) {
     logger.info('[createAssistant] Thread already exists');
     const updateFields = { active: true, stopped: false };
     Thread.setAssistantId(updateFields, assistant_id);    
     await Thread.updateOne({ code: code }, { $set: updateFields });
     return findThread;
   }
+
+  if (force && findThread?.getConversationId()) {
+    const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
+    await provider.deleteConversation(findThread.getConversationId());
+    logger.info('[createAssistant] Deleted old conversation, will create new one');
+  }
   
   const curRow = await getCurRow(Historial_Clinico_ID, code);
   logger.info('[createAssistant] curRow', curRow[0]);
@@ -153,7 +160,6 @@ const createAssistant = async (code, assistant_id, messages=[], force=false) =>
   const assistant = getAssistantById(assistant_id, null);
   const initialThread = await assistant.create(code, curRow[0]);
 
-  // Add new messages to memory
   const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
   for (const message of messages) {
     await provider.addMessage({
@@ -177,29 +183,32 @@ const createAssistant = async (code, assistant_id, messages=[], force=false) =>
   const updatedThread = await Thread.findOneAndUpdate(condition, {run_id: null, ...thread}, options);
   logger.info('[createAssistant] Updated thread:', updatedThread);
 
-  // Delete previous thread
-  if (force) {
-    await provider.deleteConversation(findThread.getConversationId());
-  }
-
   return thread;
 };
 
 const addMsgAssistant = async (code, inMessages, role = 'user', reply = false) => {
   try {
-    const thread = await Thread.findOne({ code: code });
+    let thread = await Thread.findOne({ code: code });
     logger.info(thread);
     if (thread === null) return null;
 
     const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
-    for (const message of inMessages) {
-      logger.info(message);
-      await provider.addMessage({
-        threadId: thread.getConversationId(),
-        role: role,
-        content: message
-      });
-    }
+    
+    await withThreadRecovery(
+      async (recoveredThread = thread) => {
+        thread = recoveredThread;
+        for (const message of inMessages) {
+          logger.info(message);
+          await provider.addMessage({
+            threadId: thread.getConversationId(),
+            role: role,
+            content: message
+          });
+        }
+      },
+      thread,
+      process.env.VARIANT || 'assistants'
+    );
 
     if (!reply) return null;
 
@@ -322,9 +331,15 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
   const allTempFiles = processResults.flatMap(r => r.tempFiles || []);
   
   if (allMessagesToAdd.length > 0) {
-    const threadId = finalThread.getConversationId();
     logger.info(`[replyAssistantCore] Adding ${allMessagesToAdd.length} messages to thread in batch`);
-    await provider.addMessage({ threadId, messages: allMessagesToAdd });
+    await withThreadRecovery(
+      async (thread = finalThread) => {
+        const threadId = thread.getConversationId();
+        await provider.addMessage({ threadId, messages: allMessagesToAdd });
+      },
+      finalThread,
+      process.env.VARIANT || 'assistants'
+    );
   }
   
   await Promise.all(processResults.map(r => updateMessageRecord(r.reply, finalThread)));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peopl-health/nexus",
-  "version": "2.4.9",
+  "version": "2.4.10",
   "description": "Core messaging and assistant library for WhatsApp communication platforms",
   "keywords": [
     "whatsapp",