@peopl-health/nexus 3.5.8 → 3.5.10

package/lib/controllers/conversationController.js

@@ -13,7 +13,7 @@ const { withThreadRecovery } = require('../helpers/threadRecoveryHelper');
 const { ensureWhatsAppFormat } = require('../helpers/twilioHelper');
 
 const { getRecordByFilter } = require('../services/airtableService');
-const { fetchConversationData, processConversations } = require('../services/conversationService');
+const { fetchConversationData, processConversations, startConversation } = require('../services/conversationService');
 
 const { sendMessage } = require('../core/NexusMessaging');
 
@@ -672,6 +672,34 @@ const searchMessagesByNumberController = async (req, res) => {
   }
 };
 
+const startConversationController = async (req, res) => {
+  try {
+    const { phoneNumber, name, message } = req.body;
+
+    if (!phoneNumber || !message) {
+      return res.status(400).json({
+        success: false,
+        error: 'Phone number and message are required'
+      });
+    }
+
+    const formattedPhoneNumber = ensureWhatsAppFormat(phoneNumber);
+    const result = await startConversation(formattedPhoneNumber, message, name);
+
+    res.status(201).json({
+      success: true,
+      message: 'Conversation started, template pending approval',
+      ...result
+    });
+  } catch (error) {
+    logger.error('[StartConversation] Error', { error: error.message });
+    res.status(500).json({
+      success: false,
+      error: error.message || 'Failed to start conversation'
+    });
+  }
+};
+
 module.exports = {
   getConversationController,
   getConversationMessagesController,
@@ -682,5 +710,6 @@ module.exports = {
   markMessagesAsReadController,
   searchConversationsController,
   sendTemplateToNewNumberController,
+  startConversationController,
   getOpenAIThreadMessagesController
 };

package/lib/core/NexusMessaging.js

@@ -229,6 +229,9 @@ class NexusMessaging {
       });
     }
 
+    const chatId = messageData.code;
+    if (chatId) ensureThreadExists(chatId);
+
     let content = messageData.body || messageData.message;
     if (!content && messageData.contentSid) {
       try {

package/lib/helpers/templateApprovalPoller.js

@@ -0,0 +1,59 @@
+const { logger } = require('../utils/logger');
+
+const getMessaging = () => require('../core/NexusMessaging');
+
+const MAX_ATTEMPTS = 40;
+const POLL_INTERVAL_MS = 15 * 60 * 1000;
+
+function pollTemplateApproval(templateSid, { label, logContext = {}, onApproved, onRejected }) {
+  const { requireProvider } = getMessaging();
+  const provider = requireProvider();
+
+  const poll = (attempt = 0) => {
+    if (attempt >= MAX_ATTEMPTS) {
+      logger.warn(`${label} Max approval poll attempts reached, giving up`, { ...logContext, templateSid, attempts: MAX_ATTEMPTS });
+      return;
+    }
+
+    logger.info(`${label} Scheduling approval check`, { ...logContext, templateSid, attempt, nextCheckInMs: POLL_INTERVAL_MS });
+
+    setTimeout(() => {
+      (async () => {
+        logger.info(`${label} Checking approval status`, { ...logContext, templateSid, attempt });
+
+        const status = await provider.checkApprovalStatus(templateSid);
+        const approvalStatus = status?.approvalRequest?.status?.toUpperCase();
+
+        logger.info(`${label} Approval status received`, { ...logContext, templateSid, approvalStatus, attempt });
+
+        if (approvalStatus === 'APPROVED') {
+          await onApproved(provider);
+        } else if (approvalStatus === 'REJECTED') {
+          if (onRejected) {
+            await onRejected(provider);
+          } else {
+            logger.warn(`${label} Template rejected`, { ...logContext, templateSid });
+            try {
+              await provider.deleteTemplate(templateSid);
+              logger.info(`${label} Rejected template deleted`, { ...logContext, templateSid });
+            } catch (deleteErr) {
+              logger.warn(`${label} Failed to delete rejected template`, { ...logContext, templateSid, error: deleteErr.message });
+            }
+          }
+        } else {
+          logger.info(`${label} Still pending, will retry`, { ...logContext, templateSid, approvalStatus, attempt });
+          poll(attempt + 1);
+        }
+      })().catch((err) => {
+        logger.error(`${label} Error during approval poll`, { ...logContext, templateSid, error: err.message, attempt });
+        if (attempt + 1 < MAX_ATTEMPTS) {
+          poll(attempt + 1);
+        }
+      });
+    }, POLL_INTERVAL_MS);
+  };
+
+  poll();
+}
+
+module.exports = { pollTemplateApproval };

package/lib/helpers/templateRecoveryHelper.js

@@ -1,6 +1,7 @@
 const { logger } = require('../utils/logger');
 const { Message } = require('../models/messageModel');
 const { Template } = require('../templates/templateStructure');
+const { pollTemplateApproval } = require('./templateApprovalPoller');
 
 const getMessaging = () => require('../core/NexusMessaging');
 
@@ -29,7 +30,10 @@ async function handle24HourWindowError(message, messageSid) {
 
     const { requireProvider, sendMessage } = getMessaging();
     const provider = requireProvider();
-    if (typeof provider.createTemplate !== 'function') return;
+    if (typeof provider.createTemplate !== 'function') {
+      logger.warn('[TemplateRecovery] Provider does not support createTemplate, skipping', { messageSid });
+      return;
+    }
 
     const templateName = `auto_${Date.now()}_${Math.floor(Math.random() * 1000)}`;
     const template = new Template(templateName, 'UTILITY', 'es');
@@ -46,62 +50,46 @@ async function handle24HourWindowError(message, messageSid) {
 
     logger.info('[TemplateRecovery] Template created', { messageSid, templateSid: twilioContent.sid });
 
-    const MAX_ATTEMPTS = 40;
-    const checkApproval = async (attempt = 0) => {
-      if (attempt >= MAX_ATTEMPTS) {
-        logger.warn('[TemplateRecovery] Max attempts reached', { messageSid, templateSid: twilioContent.sid });
-        return;
-      }
+    pollTemplateApproval(twilioContent.sid, {
+      label: '[TemplateRecovery]',
+      logContext: { messageSid },
+      onApproved: async (prov) => {
+        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] Send already claimed by another process', { messageSid, templateSid: twilioContent.sid });
+          return;
+        }
 
-      setTimeout(async () => {
         try {
-          const status = await provider.checkApprovalStatus(twilioContent.sid);
-          const approvalStatus = status?.approvalRequest?.status?.toUpperCase();
-
-          if (approvalStatus === 'APPROVED') {
-            const claimSend = await Message.updateOne(
-              { message_id: messageSid, 'statusInfo.recoverySentAt': { $exists: false } },
-              { $set: { 'statusInfo.recoverySentAt': new Date() } }
-            );
-            if (!claimSend?.modifiedCount && !claimSend?.nModified) return;
-
-            try {
-              await sendMessage({ code: message.numero, contentSid: twilioContent.sid, variables: {} });
-              logger.info('[TemplateRecovery] Template sent', { messageSid, templateSid: twilioContent.sid });
-              try {
-                await provider.deleteTemplate(twilioContent.sid);
-                logger.info('[TemplateRecovery] Template deleted', { messageSid, templateSid: twilioContent.sid });
-              } catch (deleteErr) {
-                logger.warn('[TemplateRecovery] Failed to delete template after send', { messageSid, templateSid: twilioContent.sid, error: deleteErr.message });
-              }
-            } 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 });
-            try {
-              await provider.deleteTemplate(twilioContent.sid);
-              logger.info('[TemplateRecovery] Rejected template deleted', { messageSid, templateSid: twilioContent.sid });
-            } catch (deleteErr) {
-              logger.warn('[TemplateRecovery] Failed to delete rejected template', { messageSid, templateSid: twilioContent.sid, error: deleteErr.message });
-            }
-          } else {
-            checkApproval(attempt + 1);
-          }
-        } catch (err) {
-          logger.error('[TemplateRecovery] Error checking approval', { error: err.message, attempt });
-          if (attempt + 1 < MAX_ATTEMPTS) {
-            checkApproval(attempt + 1);
+          await sendMessage({ code: message.numero, contentSid: twilioContent.sid, variables: {} });
+          logger.info('[TemplateRecovery] Template sent', { messageSid, templateSid: twilioContent.sid });
+          try {
+            await prov.deleteTemplate(twilioContent.sid);
+            logger.info('[TemplateRecovery] Template deleted', { messageSid, templateSid: twilioContent.sid });
+          } catch (deleteErr) {
+            logger.warn('[TemplateRecovery] Failed to delete template after send', { messageSid, templateSid: twilioContent.sid, error: deleteErr.message });
           }
+        } 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 });
         }
-      }, 15 * 60 * 1000);
-    };
-
-    checkApproval();
+      },
+      onRejected: async (prov) => {
+        logger.warn('[TemplateRecovery] Template rejected', { messageSid, templateSid: twilioContent.sid });
+        try {
+          await prov.deleteTemplate(twilioContent.sid);
+          logger.info('[TemplateRecovery] Rejected template deleted', { messageSid, templateSid: twilioContent.sid });
+        } catch (deleteErr) {
+          logger.warn('[TemplateRecovery] Failed to delete rejected template', { messageSid, templateSid: twilioContent.sid, error: deleteErr.message });
+        }
+      }
+    });
 
   } catch (error) {
     logger.error('[TemplateRecovery] Error', { messageSid, error: error.message });

package/lib/helpers/threadHelper.js

@@ -1,7 +1,12 @@
+const { Config_ID } = require('../config/airtableConfig.js');
+const runtimeConfig = require('../config/runtimeConfig.js');
+
 const { logger } = require('../utils/logger');
 
 const { Thread } = require('../models/threadModel.js');
 
+const { getRecordByFilter } = require('../services/airtableService.js');
+
 const getThread = async (code, message = null) => {
   try {
     let thread = await Thread.findOne({ code });
@@ -33,9 +38,22 @@ const createPlaceholderThread = async (code) => {
     const existing = await Thread.findOne({ code });
     if (existing) return existing;
 
-    const thread = new Thread({ code, assistant_id: null, conversation_id: null, stopped: true });
+    const nodeEnv = runtimeConfig.get('NODE_ENV');
+    const assistantStatus = nodeEnv === 'production' ? 'prod' : nodeEnv === 'development' ? 'dev' : nodeEnv;
+    const record = await getRecordByFilter(Config_ID, 'responses', `AND({code}="PIPO_ASST", {status}="${assistantStatus}")`, undefined, ['prompt_id']);
+    const prompt_id = record?.[0]?.['prompt_id'] || null;
+
+    const thread = new Thread({ code, assistant_id: null, prompt_id, conversation_id: null, stopped: true });
     await thread.save();
-    logger.info('[createPlaceholderThread] Created', { code });
+    logger.info('[createPlaceholderThread] Created', { code, prompt_id });
+
+    if (prompt_id) {
+      // Imported here to avoid circular dependency
+      const { createAssistant } = require('../services/assistantService.js');
+      await createAssistant(code, prompt_id, [], true);
+      logger.info('[createPlaceholderThread] Assistant created', { code, prompt_id });
+    }
+
     return thread;
   } catch (error) {
     logger.error('[createPlaceholderThread] Error', { code, error: error.message });

package/lib/routes/index.js

@@ -21,6 +21,7 @@ const conversationRouteDefinitions = {
   'GET /:phoneNumber/search': 'searchMessagesByNumberController',
   'POST /reply': 'getConversationReplyController',
   'POST /send-template': 'sendTemplateToNewNumberController',
+  'POST /start': 'startConversationController',
   'POST /:phoneNumber/read': 'markMessagesAsReadController',
   'POST /case-documentation': 'caseDocumentationController',
   'POST /report-bug': 'reportBugController',
@@ -133,6 +134,7 @@ const builtInControllers = {
   getOpenAIThreadMessagesController: conversationController.getOpenAIThreadMessagesController,
   getConversationReplyController: conversationController.getConversationReplyController,
   sendTemplateToNewNumberController: conversationController.sendTemplateToNewNumberController,
+  startConversationController: conversationController.startConversationController,
   markMessagesAsReadController: conversationController.markMessagesAsReadController,
   searchMessagesByNumberController: conversationController.searchMessagesByNumberController,
   reportBugController: bugReportController.reportBugController,

package/lib/services/conversationService.js

@@ -1,11 +1,20 @@
 const { Historial_Clinico_ID } = require('../config/airtableConfig');
 
 const { logger } = require('../utils/logger');
+const { parseDate } = require('../utils/dateUtils');
 
 const { Message } = require('../models/messageModel');
+const { Thread } = require('../models/threadModel');
+const TemplateModel = require('../models/templateModel');
+
+const { pollTemplateApproval } = require('../helpers/templateApprovalPoller');
 
 const { getRecordByFilter } = require('../services/airtableService');
 
+const { sendMessage, requireProvider } = require('../core/NexusMessaging');
+
+const { Template } = require('../templates/templateStructure');
+
 const BASE_MATCH = { group_id: null };
 const UNREAD_MATCH = { from_me: false, $or: [{ read: false }, { read: { $exists: false } }] };
 const PENDING_REVIEW_MATCH = { $or: [{ review: false }, { review: null }] };
@@ -151,7 +160,105 @@ const processConversations = async (conversations, nameMap, unreadMap) => {
   }
 };
 
+const startConversation = async (phoneNumber, message, name) => {
+  const thread = await Thread.findOneAndUpdate(
+    { code: phoneNumber },
+    {
+      code: phoneNumber,
+      ...(name && { nombre: name }),
+      active: true
+    },
+    { upsert: true, new: true }
+  );
+
+  logger.info('[StartConversation] Thread ready', { phoneNumber, threadId: thread._id, name });
+
+  const provider = requireProvider();
+  const templateName = `start_${Date.now()}`;
+  const template = new Template(templateName, 'UTILITY', 'es');
+  template.setBody(message, []);
+  const twilioContent = await template.save();
+
+  const currentDate = new Date();
+  const dateCreated = parseDate(twilioContent.dateCreated, currentDate);
+
+  await TemplateModel.create({
+    sid: twilioContent.sid,
+    name: (twilioContent.friendlyName || `template_${twilioContent.sid}`).replace(/[^a-zA-Z0-9_]/g, '_').toLowerCase(),
+    friendlyName: twilioContent.friendlyName,
+    category: 'UTILITY',
+    language: 'es',
+    status: twilioContent.status,
+    body: message,
+    variables: [],
+    components: twilioContent.components || [],
+    dateCreated,
+    lastUpdated: currentDate
+  });
+
+  const timestamp = Date.now().toString();
+  const randomSuffix = Math.floor(Math.random() * 1000).toString().padStart(3, '0');
+  const approvalName = `${templateName}_${timestamp}_${randomSuffix}`.toLowerCase().replace(/[^a-z0-9_]/g, '_');
+  const approvalResponse = await provider.submitForApproval(twilioContent.sid, approvalName, 'UTILITY');
+
+  const validSubmittedDate = parseDate(approvalResponse.date_created || approvalResponse.dateCreated);
+  const validUpdatedDate = parseDate(approvalResponse.date_updated || approvalResponse.dateUpdated, validSubmittedDate);
+
+  await TemplateModel.updateOne(
+    { sid: twilioContent.sid },
+    {
+      status: 'PENDING',
+      approvalRequest: {
+        sid: approvalResponse.sid,
+        status: approvalResponse.status || 'PENDING',
+        dateSubmitted: validSubmittedDate,
+        dateUpdated: validUpdatedDate,
+        rejectionReason: approvalResponse.rejection_reason || ''
+      }
+    }
+  );
+
+  logger.info('[StartConversation] Template created and submitted for approval', {
+    phoneNumber,
+    templateSid: twilioContent.sid,
+    approvalStatus: approvalResponse.status
+  });
+
+  pollTemplateApproval(twilioContent.sid, {
+    label: '[StartConversation]',
+    logContext: { phoneNumber },
+    onApproved: async (prov) => {
+      await sendMessage({ code: phoneNumber, contentSid: twilioContent.sid, variables: {} });
+      logger.info('[StartConversation] Template sent successfully', { phoneNumber, templateSid: twilioContent.sid });
+      await TemplateModel.updateOne({ sid: twilioContent.sid }, { status: 'APPROVED' });
+      try {
+        await prov.deleteTemplate(twilioContent.sid);
+        logger.info('[StartConversation] Template cleaned up', { templateSid: twilioContent.sid });
+      } catch (deleteErr) {
+        logger.warn('[StartConversation] Failed to delete template after send', { templateSid: twilioContent.sid, error: deleteErr.message });
+      }
+    },
+    onRejected: async (prov) => {
+      logger.warn('[StartConversation] Template rejected', { phoneNumber, templateSid: twilioContent.sid });
+      await TemplateModel.updateOne({ sid: twilioContent.sid }, { status: 'REJECTED' });
+      try {
+        await prov.deleteTemplate(twilioContent.sid);
+      } catch (deleteErr) {
+        logger.warn('[StartConversation] Failed to delete rejected template', { templateSid: twilioContent.sid, error: deleteErr.message });
+      }
+    }
+  });
+
+  return {
+    phoneNumber,
+    threadId: thread._id,
+    contentSid: twilioContent.sid,
+    approvalStatus: approvalResponse.status || 'PENDING'
+  };
+};
+
 module.exports = {
   fetchConversationData,
-  processConversations
+  processConversations,
+  startConversation
 };

package/package.json

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