@peopl-health/nexus 3.3.2 → 3.3.4

package/lib/controllers/conversationController.js

@@ -314,31 +314,48 @@ const searchConversationsController = async (req, res) => {
 
     const escapedQuery = query.replace(/\+/g, '\\+');
 
-    // Search through all conversations in the database
+    // Prioritize matches on numero/nombre_whatsapp; body search is a last resort.
     const conversations = await Message.aggregate([
-      { $match: { 
-        group_id: null,
-        $or: [
-          { numero: { $regex: escapedQuery, $options: 'i' } },
-          { nombre_whatsapp: { $regex: escapedQuery, $options: 'i' } },
-          { body: { $regex: escapedQuery, $options: 'i' } }
-        ]
-      }},
-      { $project: {
-        numero: 1,
-        body: 1,
-        createdAt: 1,
-        timestamp: 1,
-        media: 1,
-        nombre_whatsapp: 1,
-        from_me: 1
-      }},
-      { $group: {
-        _id: '$numero',
-        latestMessage: { $first: '$$ROOT' },
-        messageCount: { $sum: 1 }
-      }},
-      { $sort: { 'latestMessage.createdAt': -1 } },
+      {
+        $facet: {
+          primary: [
+            { $match: { 
+              group_id: null,
+              $or: [
+                { numero: { $regex: escapedQuery, $options: 'i' } },
+                { nombre_whatsapp: { $regex: escapedQuery, $options: 'i' } }
+              ]
+            }},
+            { $sort: { createdAt: -1, timestamp: -1 } },
+            { $group: {
+              _id: '$numero',
+              latestMessage: { $first: '$$ROOT' },
+              messageCount: { $sum: 1 }
+            }},
+            { $addFields: { priority: 1 } }
+          ],
+          secondary: [
+            { $match: { 
+              group_id: null,
+              body: { $regex: escapedQuery, $options: 'i' }
+            }},
+            { $sort: { createdAt: -1, timestamp: -1 } },
+            { $group: {
+              _id: '$numero',
+              latestMessage: { $first: '$$ROOT' },
+              messageCount: { $sum: 1 }
+            }},
+            { $addFields: { priority: 2 } }
+          ]
+        }
+      },
+      { $project: { merged: { $concatArrays: ['$primary', '$secondary'] } } },
+      { $unwind: '$merged' },
+      { $replaceRoot: { newRoot: '$merged' } },
+      { $sort: { priority: 1, 'latestMessage.createdAt': -1 } },
+      // Deduplicate numbers keeping highest-priority (name/number) result first
+      { $group: { _id: '$_id', doc: { $first: '$$ROOT' } } },
+      { $replaceRoot: { newRoot: '$doc' } },
       { $limit: parsedLimit }
     ]);
 
@@ -741,4 +758,4 @@ module.exports = {
   searchConversationsController,
   sendTemplateToNewNumberController,
   getOpenAIThreadMessagesController
-};
+};

package/lib/core/NexusMessaging.js

@@ -563,6 +563,12 @@ class NexusMessaging {
           prompt,
           response_id
         });
+      } else {
+        await this.sendMessage({ 
+          code: 'whatsapp:+51951538602',
+          body: `Error no se genero respuesta ${from}`,
+          origin: 'assistant'
+        });
       }
     } catch (error) {
       logger.error('Error in handleMediaWithAssistant:', error);

package/lib/helpers/messageStatusHelper.js

@@ -102,5 +102,4 @@ module.exports = {
   updateMessageStatus,
   handleStatusCallback,
   getMessageStatus
-};
-
+};

package/lib/helpers/templateRecoveryHelper.js

@@ -11,6 +11,26 @@ async function handle24HourWindowError(message, messageSid) {
   try {
     if (!message?.body || !message?.numero) return;
 
+    if (message?.statusInfo?.recoveryTemplateSid || message?.statusInfo?.recoverySentAt) {
+      logger.info('[TemplateRecovery] Recovery already completed or in progress', { messageSid });
+      return;
+    }
+
+    // Guard: avoid duplicate recovery for the same message (race-safe)
+    try {
+      const claim = await Message.updateOne(
+        { message_id: messageSid, 'statusInfo.recoveryStartedAt': { $exists: false } },
+        { $set: { 'statusInfo.recoveryStartedAt': new Date() } }
+      );
+      if (!claim.modifiedCount && !claim.nModified) {
+        logger.info('[TemplateRecovery] Recovery already in progress or completed', { messageSid });
+        return;
+      }
+    } catch (claimErr) {
+      logger.warn('[TemplateRecovery] Could not set recovery start flag; aborting to avoid duplicates', { messageSid, error: claimErr.message });
+      return;
+    }
+
     const messaging = getDefaultInstance();
     const provider = messaging?.getProvider();
     if (!provider?.createTemplate) return;
@@ -45,8 +65,26 @@ async function handle24HourWindowError(message, messageSid) {
           const approvalStatus = status?.approvalRequest?.status?.toUpperCase();
           
           if (approvalStatus === 'APPROVED') {
-            await sendMessage({ code: message.numero, contentSid: twilioContent.sid, variables: {} });
-            logger.info('[TemplateRecovery] Template sent', { messageSid, templateSid: twilioContent.sid });
+            const claimSend = await Message.updateOne(
+              { message_id: messageSid, 'statusInfo.recoverySentAt': { $exists: false } },
+              { $set: { 'statusInfo.recoverySentAt': new Date() } }
+            );
+
+            if (!claimSend.modifiedCount && !claimSend.nModified) {
+              logger.info('[TemplateRecovery] Template already sent, skipping duplicate send', { messageSid, templateSid: twilioContent.sid });
+              return;
+            }
+
+            try {
+              await sendMessage({ code: message.numero, contentSid: twilioContent.sid, variables: {} });
+              logger.info('[TemplateRecovery] Template sent', { messageSid, templateSid: twilioContent.sid });
+            } catch (sendErr) {
+              await Message.updateOne(
+                { message_id: messageSid },
+                { $unset: { 'statusInfo.recoverySentAt': '' } }
+              );
+              logger.error('[TemplateRecovery] Error sending approved template', { messageSid, templateSid: twilioContent.sid, error: sendErr.message });
+            }
           } else if (approvalStatus === 'REJECTED') {
             logger.warn('[TemplateRecovery] Template rejected', { messageSid, templateSid: twilioContent.sid });
           } else {

package/lib/models/messageModel.js

@@ -72,7 +72,10 @@ const messageSchema = new mongoose.Schema({
     },
     errorCode: { type: String, default: null },
     errorMessage: { type: String, default: null },
-    updatedAt: { type: Date, default: null }
+    updatedAt: { type: Date, default: null },
+    recoveryTemplateSid: { type: String, default: null },
+    recoveryStartedAt: { type: Date, default: null },
+    recoverySentAt: { type: Date, default: null }
   },
   prompt: { type: Object, default: null },
   response_id: { type: String, default: null }

package/lib/providers/OpenAIResponsesProvider.js

@@ -7,6 +7,7 @@ const {
 } = require('./OpenAIResponsesProviderTools');
 const { DefaultMemoryManager } = require('../memory/DefaultMemoryManager');
 const { getRecordByFilter } = require('../services/airtableService');
+const { getLastNMessages } = require('../helpers/messageHelper');
 const { logger } = require('../utils/logger');
 const { getCurrentMexicoDateTime } = require('../utils/dateUtils');
 
@@ -203,6 +204,12 @@ class OpenAIResponsesProvider {
         }
       });
 
+      const lastMessage = await getLastNMessages(thread.code, 1);
+      const metadata = {
+        numero: thread.code,
+        message_id: message?.message_id || (lastMessage.length > 0 ? lastMessage[0].message_id : null) || null
+      };
+
       logger.info('[OpenAIResponsesProvider] Context built', {
         conversationId,
         assistantId,
@@ -228,6 +235,7 @@ class OpenAIResponsesProvider {
         promptVariables,
         promptVersion,
         assistant,
+        metadata,
         ...config
       });
 
@@ -268,87 +276,130 @@ class OpenAIResponsesProvider {
     }
   }
 
-  async runConversation({
-    threadId,
-    assistantId,
-    additionalMessages = [],
-    context = null,
-    instructions = null,
-    additionalInstructions = null,
-    metadata = {},
-    topP,
-    temperature,
-    maxOutputTokens,
-    truncationStrategy = 'auto',
-    model,
-    assistant,
-    toolMetadata,
-    promptVersion = null,
-    promptVariables = null
-  } = {}) {
-    try {
-      let totalRetries = 0;
-      let allToolsExecuted = [];
-      
-      const devRecord = await getRecordByFilter(Config_ID, 'responses', `{prompt_id} = "${assistantId}"`);
-      let devContent = devRecord?.[0]?.content || '';
-      if (promptVariables) devContent = devContent.replace(/\{\{(\w+)\}\}/g, (_, key) => promptVariables[key] ?? '');
-
-      const messages = (context || this._convertItemsToApiFormat(additionalMessages))
-        .filter(item => item.type !== 'function_call' && item.type !== 'function_call_output');
-      const input = [{ role: 'developer', content: devContent }, ...messages];
-
-      const promptConfig = { id: assistantId };
-      if (promptVariables) promptConfig.variables = promptVariables;
-      if (promptVersion) promptConfig.version = String(promptVersion);
-      logger.info('[OpenAIResponsesProvider] Prompt config', { promptConfig });
-
-      const baseInstructions = instructions || additionalInstructions || '';
-      const fullInstructions = baseInstructions;
-      //? `${baseInstructions}\n\n${this.defaults.brevityInstruction}`
-      //: this.defaults.brevityInstruction;
-
-      const makeAPICall = (inputData) => retryWithBackoff(() => 
-        this.client.responses.create({
-          prompt: promptConfig,
-          input: inputData,
-          instructions: fullInstructions
-        }), { providerName: PROVIDER_NAME });
-
-      const { result: response, retries } = await makeAPICall(input);
-      logger.info('[OpenAIResponsesProvider] Run response', { response });
-      totalRetries += retries;
-      let finalResponse = response;
-
-      // Handle function calls following OpenAI pattern
-      if (assistant && response.output) {
-        const functionCalls = response.output.filter(item => item.type === 'function_call');
+  async runConversation(config = {}) {
+    const { threadId, assistantId } = config;
+    
+    const maxRetries = parseInt(process.env.MAX_CONVERSATION_RETRIES || '3', 10);
+    
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        logger.info('[OpenAIResponsesProvider] Conversation attempt', { attempt, maxRetries, threadId, assistantId });
+        
+        const result = await this._executeConversation(config);
+        
+        if (result.output_text && result.output_text.trim().length > 0) {
+          logger.info('[OpenAIResponsesProvider] Conversation successful', { 
+            attempt, 
+            outputLength: result.output_text.length,
+            toolsExecuted: result.tools_executed?.length || 0
+          });
+          return result;
+        }
+        
+        logger.warn('[OpenAIResponsesProvider] Empty output, retrying', { attempt, maxRetries });
         
-        if (functionCalls.length > 0) {
-          const { outputs, toolsExecuted } = await handleFunctionCallsUtil(functionCalls, assistant, toolMetadata || { thread_id: threadId, assistant_id: assistantId });
-          
-          input.push(...response.output);
-          input.push(...outputs);
-          allToolsExecuted.push(...toolsExecuted);
-
-          const { result: followUp, retries: followUpRetries } = await makeAPICall(input);
-          totalRetries += followUpRetries;
-          finalResponse = followUp;
+        if (attempt === maxRetries) {
+          throw new Error(`Conversation failed after ${attempt} attempts - no valid output generated`);
         }
+        
+        await new Promise(resolve => setTimeout(resolve, 500));
+      } catch (error) {
+        logger.error('[OpenAIResponsesProvider] Conversation attempt failed', { attempt, maxRetries, error: error.message });
+        
+        if (attempt === maxRetries) {
+          throw error;
+        }
+        
+        await new Promise(resolve => setTimeout(resolve, 500));
       }
+    }
+  }
 
-      return {
-        ...finalResponse,
-        thread_id: threadId,
-        assistant_id: assistantId,
-        object: finalResponse.object || 'response',
-        tools_executed: allToolsExecuted,
-        retries: totalRetries,
-      };
-    } catch (error) {
-      logger.error('[OpenAIResponsesProvider] Error running conversation:', error);
-      throw error;
+  async _executeConversation(config = {}) {
+    const {
+      threadId,
+      assistantId,
+      additionalMessages = [],
+      context = null,
+      instructions = null,
+      additionalInstructions = null,
+      metadata = {},
+      topP,
+      temperature,
+      maxOutputTokens,
+      truncationStrategy = 'auto',
+      model,
+      assistant,
+      toolMetadata,
+      promptVersion = null,
+      promptVariables = null
+    } = config;
+    
+    let totalRetries = 0;
+    let allToolsExecuted = [];
+    
+    const devRecord = await getRecordByFilter(Config_ID, 'responses', `{prompt_id} = "${assistantId}"`);
+    let devContent = devRecord?.[0]?.content || '';
+    if (promptVariables) devContent = devContent.replace(/\{\{(\w+)\}\}/g, (_, key) => promptVariables[key] ?? '');
+
+    const messages = (context || this._convertItemsToApiFormat(additionalMessages))
+      .filter(item => item.type !== 'function_call' && item.type !== 'function_call_output');
+    const input = [{ role: 'developer', content: devContent }, ...messages];
+
+    const promptConfig = { id: assistantId };
+    if (promptVariables) promptConfig.variables = promptVariables;
+    if (promptVersion) promptConfig.version = String(promptVersion);
+
+    const baseInstructions = instructions || additionalInstructions || '';
+
+    const makeAPICall = (inputData) => retryWithBackoff(() => 
+      this.client.responses.create({
+        prompt: promptConfig,
+        input: inputData,
+        instructions: baseInstructions,
+        metadata: metadata
+      }), { providerName: PROVIDER_NAME });
+
+    const { result: response, retries } = await makeAPICall(input);
+    totalRetries += retries;
+    let finalResponse = response;
+
+    // Handle function calls with multi-round support
+    if (assistant && response.output) {
+      let currentInput = [...input];
+      let round = 1;
+      const maxRounds = parseInt(process.env.MAX_FUNCTION_ROUNDS || '5', 10);
+      
+      while (round <= maxRounds) {
+        const functionCalls = finalResponse.output.filter(item => item.type === 'function_call');
+        if (functionCalls.length === 0) break;
+        
+        const { outputs, toolsExecuted } = await handleFunctionCallsUtil(
+          functionCalls, 
+          assistant, 
+          toolMetadata || { thread_id: threadId, assistant_id: assistantId }
+        );
+        
+        currentInput.push(...finalResponse.output);
+        currentInput.push(...outputs);
+        allToolsExecuted.push(...toolsExecuted);
+
+        const { result: followUp, retries: followUpRetries } = await makeAPICall(currentInput);
+        totalRetries += followUpRetries;
+        finalResponse = followUp;
+        
+        round++;
+      }
     }
+
+    return {
+      ...finalResponse,
+      thread_id: threadId,
+      assistant_id: assistantId,
+      object: finalResponse.object || 'response',
+      tools_executed: allToolsExecuted,
+      retries: totalRetries,
+    };
   }
 
   /**

package/package.json

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