@peopl-health/nexus 2.4.9-fix-mime-type → 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/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-fix-mime-type",
+  "version": "2.4.10",
   "description": "Core messaging and assistant library for WhatsApp communication platforms",
   "keywords": [
     "whatsapp",