@peopl-health/nexus 3.15.5 → 3.15.7

package/lib/controllers/bugReportController.js

@@ -9,7 +9,10 @@ const { getBug, VALID_SEVERITIES } = require('../models/bugModel');
 const { addRecord, getRecordByFilter } = require('../services/airtableService');
 
 async function logBugReportToAirtable(reportedBug) {
-  const { reporter, whatsapp_id, description, severity, messages, server, bugType, project } = reportedBug;
+  const {
+    reporter, whatsapp_id, description, severity, messages, server, bugType, project,
+    clasificacion, status, owner, request_id
+  } = reportedBug;
   try {
     let conversation = null;
     if (messages?.length) {
@@ -22,11 +25,13 @@ async function logBugReportToAirtable(reportedBug) {
     }
 
     let patientId = null;
-    try {
-      const records = await getRecordByFilter(Logging_ID, 'estado_general', `{whatsapp_id}='${whatsapp_id}'`);
-      if (records?.length) patientId = records[0].record_logging_id;
-    } catch (err) {
-      logger.warn('Could not find patient in estado_general:', { error: err.message });
+    if (whatsapp_id) {
+      try {
+        const records = await getRecordByFilter(Logging_ID, 'estado_general', `{whatsapp_id}='${whatsapp_id}'`);
+        if (records?.length) patientId = records[0].record_logging_id;
+      } catch (err) {
+        logger.warn('Could not find patient in estado_general:', { error: err.message });
+      }
     }
 
     const bugRecord = await addRecord(Logging_ID, 'bug_reports', {
@@ -34,6 +39,10 @@ async function logBugReportToAirtable(reportedBug) {
       ...(project && {...project}),
       ...(patientId && { patient_id: [patientId] }),
       ...(conversation && { conversation }),
+      ...(clasificacion && { clasificacion }),
+      ...(status && { status }),
+      ...(owner && { owner }),
+      ...(request_id && { request_id }),
       server
     });
     logger.debug('Bug report logged to Airtable successfully');
@@ -148,4 +157,4 @@ const getBugByWhatsappIdController = async (req, res) => {
   }
 };
 
-module.exports = { reportBugController, getBugByWhatsappIdController, updateBugController };
+module.exports = { reportBugController, getBugByWhatsappIdController, updateBugController, logBugReportToAirtable };

package/lib/core/NexusMessaging.js

@@ -23,6 +23,7 @@ const { AssistantProcessor } = require('../core/AssistantProcessor');
 
 const { createQueueAdapter } = require('../queue');
 const { ScheduledMessageJob } = require('../jobs/ScheduledMessageJob');
+const { TemplateApprovalJob } = require('../jobs/TemplateApprovalJob');
 
 /**
  * Core messaging orchestrator for providers, storage, and assistant processing.
@@ -83,6 +84,16 @@ class NexusMessaging {
       queueAdapter: this.queueAdapter,
       sendMessage: this.sendMessage.bind(this)
     });
+
+    this.templateApprovalJob = new TemplateApprovalJob({
+      queueAdapter: this.queueAdapter,
+      sendMessage: this.sendMessage.bind(this),
+      requireProvider: () => {
+        const provider = this.getProvider();
+        if (!provider) throw new Error('Nexus provider not configured');
+        return provider;
+      }
+    });
   }
 
   async initialize(options = {}) {
@@ -275,6 +286,15 @@ class NexusMessaging {
     });
   }
 
+  async scheduleTemplateApproval({ templateSid, messageId, originalMessageSid = null, attempt = 0 }) {
+    return await this.templateApprovalJob.schedule({
+      templateSid,
+      messageId,
+      originalMessageSid,
+      attempt
+    });
+  }
+
   /*
    * INBOUND MESSAGE PROCESSING
    */
@@ -558,6 +578,10 @@ const sendScheduledMessage = async (scheduledMessage) => {
   return await requireDefaultInstance().sendScheduledMessage(scheduledMessage);
 };
 
+const scheduleTemplateApproval = async (options) => {
+  return await requireDefaultInstance().scheduleTemplateApproval(options);
+};
+
 const processInstruction = async (code, instruction, role, options) => {
   return await requireDefaultInstance().processInstruction(code, instruction, role, options);
 };
@@ -574,6 +598,7 @@ module.exports = {
   NexusMessaging,
   sendMessage,
   sendScheduledMessage,
+  scheduleTemplateApproval,
   processInstruction,
   processSystemMessage,
   setDefaultInstance,

package/lib/helpers/templateRecoveryHelper.js

@@ -1,7 +1,6 @@
 const { logger } = require('../utils/logger');
 const { Message } = require('../models/messageModel');
 const { Template } = require('../templates/templateStructure');
-const { pollTemplateApproval } = require('./templateApprovalPoller');
 
 const getMessaging = () => require('../core/NexusMessaging');
 
@@ -30,7 +29,7 @@ async function handle24HourWindowError(message, messageSid) {
       return;
     }
 
-    const { requireProvider } = getMessaging();
+    const { requireProvider, scheduleTemplateApproval } = getMessaging();
     const provider = requireProvider();
     if (typeof provider.createTemplate !== 'function') {
       logger.warn('[TemplateRecovery] Provider does not support createTemplate, skipping', { messageSid });
@@ -52,65 +51,11 @@ async function handle24HourWindowError(message, messageSid) {
 
     logger.info('[TemplateRecovery] Template created', { messageSid, templateSid: twilioContent.sid });
 
-    pollTemplateApproval(twilioContent.sid, {
-      label: '[TemplateRecovery]',
-      logContext: { messageSid },
-      onApproved: async (prov) => {
-        const claimSend = await Message.updateOne(
-          { _id: messageDocId, '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;
-        }
-
-        let newMessageId;
-        try {
-          const sendResult = await provider.sendMessage({
-            code: message.numero,
-            contentSid: twilioContent.sid,
-            variables: {},
-            _skipStorage: true
-          });
-          newMessageId = sendResult?.messageId;
-          if (!newMessageId) throw new Error('Provider did not return a messageId for the recovery send');
-        } catch (sendErr) {
-          await Message.updateOne(
-            { _id: messageDocId },
-            { $unset: { 'statusInfo.recoverySentAt': '' } }
-          );
-          logger.error('[TemplateRecovery] Error sending approved template', { messageSid, templateSid: twilioContent.sid, error: sendErr.message });
-          return;
-        }
-
-        try {
-          await Message.updateOne(
-            { _id: messageDocId },
-            { $set: { 'statusInfo.recoveryMessageId': newMessageId } }
-          );
-          logger.info('[TemplateRecovery] Recovered', { originalMessageId: messageSid, recoveryMessageId: newMessageId, templateSid: twilioContent.sid });
-        } catch (dbErr) {
-          logger.error('[TemplateRecovery] CRITICAL: send succeeded but DB update failed — status tracking lost for recovery delivery', {
-            messageSid, newMessageId, templateSid: twilioContent.sid, error: dbErr.message
-          });
-        }
-
-        prov.deleteTemplate(twilioContent.sid).catch(deleteErr =>
-          logger.warn('[TemplateRecovery] Failed to delete template after send', { newMessageId, templateSid: twilioContent.sid, error: deleteErr.message })
-        );
-      },
-      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 });
-        }
-      }
+    await scheduleTemplateApproval({
+      templateSid: twilioContent.sid,
+      messageId: messageDocId,
+      originalMessageSid: messageSid
     });
-
   } catch (error) {
     logger.error('[TemplateRecovery] Error', { messageSid, error: error.message });
   }

package/lib/jobs/ScheduledMessageJob.js

@@ -12,6 +12,7 @@ const DEFAULT_JOB_OPTIONS = {
 };
 
 const TERMINAL_STATUSES = ['sent', 'cancelled'];
+const STALE_SENDING_MS = 5 * 60 * 1000;
 
 class ScheduledMessageJob extends BaseJob {
   constructor({ queueAdapter, sendMessage } = {}) {
@@ -67,14 +68,27 @@ class ScheduledMessageJob extends BaseJob {
       return { success: false, reason: 'already_processed', status: msg.status };
     }
 
+    const staleThreshold = new Date(Date.now() - STALE_SENDING_MS);
     const claim = await ScheduledMessage.updateOne(
-      { _id: scheduledMessageId, status: { $nin: TERMINAL_STATUSES.concat(['sending']) } },
+      {
+        _id: scheduledMessageId,
+        $or: [
+          { status: { $nin: TERMINAL_STATUSES.concat(['sending']) } },
+          { status: 'sending', sendingAt: { $lt: staleThreshold } }
+        ]
+      },
       { $set: { status: 'sending', sendingAt: new Date() } }
     );
     if (!claim.modifiedCount && !claim.nModified) {
       logger.info('[ScheduledMessageJob] Send already claimed by another worker', { scheduledMessageId });
       return { success: false, reason: 'already_claimed' };
     }
+    if (msg.status === 'sending') {
+      logger.warn('[ScheduledMessageJob] Re-claimed stale sending state, prior worker likely crashed', {
+        scheduledMessageId,
+        priorSendingAt: msg.sendingAt
+      });
+    }
 
     try {
       const result = await this.sendMessage({

package/lib/jobs/TemplateApprovalJob.js

@@ -1,8 +1,10 @@
 const { logger } = require('../utils/logger');
+const { Message } = require('../models/messageModel');
 const { BaseJob } = require('./BaseJob');
 
 const QUEUE_NAME = 'template-approval';
 const DEFAULT_DELAY_MS = 15 * 60 * 1000;
+const MAX_ATTEMPTS = 40;
 
 const DEFAULT_JOB_OPTIONS = {
   attempts: 3,
@@ -12,8 +14,16 @@ const DEFAULT_JOB_OPTIONS = {
 };
 
 class TemplateApprovalJob extends BaseJob {
-  constructor({ queueAdapter } = {}) {
+  constructor({ queueAdapter, sendMessage, requireProvider } = {}) {
     super({ queueAdapter, queueName: QUEUE_NAME });
+    if (typeof sendMessage !== 'function') {
+      throw new Error('TemplateApprovalJob requires a sendMessage function');
+    }
+    if (typeof requireProvider !== 'function') {
+      throw new Error('TemplateApprovalJob requires a requireProvider function');
+    }
+    this.sendMessage = sendMessage;
+    this.requireProvider = requireProvider;
   }
 
   async schedule({ templateSid, messageId, originalMessageSid = null, attempt = 0, delayMs = DEFAULT_DELAY_MS }) {
@@ -36,9 +46,123 @@ class TemplateApprovalJob extends BaseJob {
     return `template-approval-${templateSid}-${attempt}`;
   }
 
-  async _process(data) {
-    logger.warn('[TemplateApprovalJob] Processor stub invoked; real implementation pending', data);
-    return { success: false, reason: 'not_implemented' };
+  async _process({ templateSid, messageId, originalMessageSid, attempt = 0 }) {
+    const message = await Message.findById(messageId).lean();
+
+    if (!message) {
+      logger.warn('[TemplateApprovalJob] Message not found', { messageId, templateSid });
+      return { success: false, reason: 'not_found' };
+    }
+
+    const recovery = message.statusInfo || {};
+    if (recovery.recoveryMessageId || recovery.recoveryRejectedAt) {
+      logger.info('[TemplateApprovalJob] Recovery already completed', { messageId, templateSid });
+      return { success: false, reason: 'already_completed' };
+    }
+    if (recovery.recoveryTemplateSid && recovery.recoveryTemplateSid !== templateSid) {
+      logger.info('[TemplateApprovalJob] Template superseded', { messageId, templateSid, currentTemplateSid: recovery.recoveryTemplateSid });
+      return { success: false, reason: 'template_superseded' };
+    }
+
+    let provider;
+    let approvalStatus;
+    try {
+      provider = this.requireProvider();
+      const status = await provider.checkApprovalStatus(templateSid);
+      approvalStatus = status?.approvalRequest?.status?.toUpperCase();
+    } catch (err) {
+      logger.error('[TemplateApprovalJob] Provider error during approval check, treating as transient', {
+        templateSid, messageId, attempt, error: err.message
+      });
+      return await this._rescheduleOrGiveUp({ templateSid, messageId, originalMessageSid, attempt, reason: 'error' });
+    }
+
+    logger.info('[TemplateApprovalJob] Approval status', { templateSid, approvalStatus, attempt, messageId, originalMessageSid });
+
+    if (approvalStatus === 'APPROVED') {
+      return await this._handleApproved({ provider, message, templateSid, originalMessageSid });
+    }
+    if (approvalStatus === 'REJECTED') {
+      return await this._handleRejected({ provider, message, templateSid });
+    }
+
+    return await this._rescheduleOrGiveUp({ templateSid, messageId, originalMessageSid, attempt, reason: 'pending' });
+  }
+
+  async _rescheduleOrGiveUp({ templateSid, messageId, originalMessageSid, attempt, reason }) {
+    const nextAttempt = attempt + 1;
+    if (nextAttempt >= MAX_ATTEMPTS) {
+      logger.warn('[TemplateApprovalJob] Max attempts reached, giving up', { templateSid, messageId, attempt, reason });
+      return { success: false, reason: 'max_attempts', priorReason: reason };
+    }
+    await this.schedule({ templateSid, messageId, originalMessageSid, attempt: nextAttempt });
+    return { success: false, reason, nextAttempt };
+  }
+
+  async _handleApproved({ provider, message, templateSid, originalMessageSid }) {
+    const claim = await Message.updateOne(
+      { _id: message._id, 'statusInfo.recoverySentAt': { $exists: false } },
+      { $set: { 'statusInfo.recoverySentAt': new Date() } }
+    );
+    if (!claim.modifiedCount && !claim.nModified) {
+      logger.info('[TemplateApprovalJob] Send already claimed by another worker', { templateSid, messageId: message._id });
+      return { success: false, reason: 'already_claimed' };
+    }
+
+    let recoveryMessageId;
+    try {
+      const sendResult = await this.sendMessage({
+        code: message.numero,
+        contentSid: templateSid,
+        variables: {},
+        _skipStorage: true
+      });
+      recoveryMessageId = sendResult?.messageId;
+      if (!recoveryMessageId) {
+        throw new Error('Provider did not return a messageId for the recovery send');
+      }
+    } catch (sendErr) {
+      await Message.updateOne(
+        { _id: message._id },
+        { $unset: { 'statusInfo.recoverySentAt': '' } }
+      );
+      logger.error('[TemplateApprovalJob] Send failed', { templateSid, messageId: message._id, error: sendErr.message });
+      throw sendErr;
+    }
+
+    try {
+      await Message.updateOne(
+        { _id: message._id },
+        { $set: { 'statusInfo.recoveryMessageId': recoveryMessageId } }
+      );
+      logger.info('[TemplateApprovalJob] Recovered', { originalMessageSid, recoveryMessageId, templateSid });
+    } catch (dbErr) {
+      logger.error('[TemplateApprovalJob] CRITICAL: send succeeded but DB update failed', {
+        messageId: message._id, templateSid, recoveryMessageId, error: dbErr.message
+      });
+    }
+
+    provider.deleteTemplate(templateSid).catch((deleteErr) =>
+      logger.warn('[TemplateApprovalJob] Failed to delete template after send', { templateSid, error: deleteErr.message })
+    );
+
+    return { success: true, recoveryMessageId };
+  }
+
+  async _handleRejected({ provider, message, templateSid }) {
+    await Message.updateOne(
+      { _id: message._id },
+      { $set: { 'statusInfo.recoveryRejectedAt': new Date() } }
+    );
+
+    try {
+      await provider.deleteTemplate(templateSid);
+      logger.info('[TemplateApprovalJob] Rejected template deleted', { templateSid, messageId: message._id });
+    } catch (deleteErr) {
+      logger.warn('[TemplateApprovalJob] Failed to delete rejected template', { templateSid, error: deleteErr.message });
+    }
+
+    return { success: false, reason: 'rejected' };
   }
 }
 

package/lib/models/messageModel.js

@@ -84,7 +84,8 @@ const messageSchema = new mongoose.Schema({
     recoveryTemplateSid: { type: String, default: null },
     recoveryStartedAt: { type: Date, default: null },
     recoverySentAt: { type: Date, default: null },
-    recoveryMessageId: { type: String, default: null }
+    recoveryMessageId: { type: String, default: null },
+    recoveryRejectedAt: { type: Date, default: null }
   },
   prompt: { type: Object, default: null },
   preset: { type: Object, default: null },

package/lib/providers/OpenAIResponsesProvider.js

@@ -1,5 +1,6 @@
 const { OpenAI } = require('openai');
 
+const runtimeConfig = require('../config/runtimeConfig');
 const { retryWithBackoff } = require('../utils/retryUtils');
 const { logger } = require('../utils/logger');
 const { getCurrentMexicoDateTime } = require('../utils/dateUtils');
@@ -10,6 +11,7 @@ const { getLastNMessages } = require('../helpers/messageHelper');
 
 const { composePrompt, resolveTools } = require('../services/promptComposerService');
 const { getToolSchemas: getRegistrySchemas } = require('../services/toolRegistryService');
+const { logBugReportToAirtable } = require('../controllers/bugReportController');
 const { handleFunctionCalls } = require('./OpenAIResponsesProviderTools');
 
 const CONVERSATION_PREFIX = 'conv_';
@@ -171,12 +173,40 @@ class OpenAIResponsesProvider {
     if (result.output && Array.isArray(result.output)) {
       const messageItems = result.output.filter(item => item && item.type === 'message');
       if (messageItems.length > 0) {
-        const lastMessage = messageItems[messageItems.length - 1];
+        if (messageItems.length > 1) {
+          const hasFunctionCalls = result.output.some(item => item?.type === 'function_call');
+          logger.warn('[OpenAIResponsesProvider] Multiple message items in response; keeping the first (likely OpenAI multi-output bug)', {
+            discarded: messageItems.length - 1,
+            responseId: result.id,
+            model: result.model,
+            hasFunctionCalls
+          });
+          logBugReportToAirtable({
+            reporter: 'system',
+            description: [
+              'OpenAI Responses API returned multiple message items in a single response.',
+              'Suspected upstream bug (model failed to emit stop-of-message token).',
+              `Discarded ${messageItems.length - 1} extra message(s); kept the first as the canonical reply.`,
+              `Response ID: ${result.id || 'unknown'}`,
+              `Model: ${result.model || 'unknown'}`,
+              `Function calls present: ${hasFunctionCalls ? 'yes' : 'no'}`
+            ].join('\n'),
+            severity: 'medium',
+            status: 'Open',
+            clasificacion: 'alucinaciones',
+            bugType: 'backend',
+            owner: ['ariana'],
+            request_id: result.id || null,
+            server: runtimeConfig.get('SERVICE_NAME') || 'nexus'
+          }).catch((err) => logger.warn('[OpenAIResponsesProvider] Bug report logger failed', { error: err.message }));
+        }
+
+        const firstMessage = messageItems[0];
         let text = '';
-        if (lastMessage.content && Array.isArray(lastMessage.content)) {
-          text = lastMessage.content.map(c => this._contentPartToText(c)).filter(Boolean).join('');
-        } else if (typeof lastMessage.content === 'string') {
-          text = lastMessage.content;
+        if (firstMessage.content && Array.isArray(firstMessage.content)) {
+          text = firstMessage.content.map(c => this._contentPartToText(c)).filter(Boolean).join('');
+        } else if (typeof firstMessage.content === 'string') {
+          text = firstMessage.content;
         }
         if (text.trim()) return text.trim();
       }
@@ -253,7 +283,7 @@ class OpenAIResponsesProvider {
       this.sessionManager?.recordActivity(thread.code);
 
       const completed = result.status === 'completed';
-      const output = this._extractMessageOutput(result);
+      const output = result.output_text || this._extractMessageOutput(result);
       const toolsExecuted = result.tools_executed?.length || 0;
 
       logger.info('[executeRun] Complete', {

package/lib/queue/LocalQueueAdapter.js

@@ -11,7 +11,14 @@ class LocalQueueAdapter extends QueueAdapter {
   }
 
   async enqueue(jobType, payload, options = {}) {
-    const jobId = `local_${++this.jobCounter}_${Date.now()}`;
+    if (options.jobId && this.jobs.has(options.jobId)) {
+      const existing = this.jobs.get(options.jobId);
+      if (existing.status === 'pending' || existing.status === 'delayed') {
+        return existing.id;
+      }
+    }
+
+    const jobId = options.jobId || `local_${++this.jobCounter}_${Date.now()}`;
     const job = {
       id: jobId,
       type: jobType,
@@ -21,12 +28,16 @@ class LocalQueueAdapter extends QueueAdapter {
       result: null,
       error: null,
       createdAt: new Date(),
-      completedAt: null
+      completedAt: null,
+      timeoutHandle: null
     };
 
     this.jobs.set(jobId, job);
 
-    setImmediate(async () => {
+    const runHandler = async () => {
+      job.timeoutHandle = null;
+      if (job.status === 'cancelled') return;
+
       const handler = this.handlers.get(jobType);
       if (!handler) {
         job.status = 'failed';
@@ -46,7 +57,14 @@ class LocalQueueAdapter extends QueueAdapter {
       }
       this.events.emit(`job:${jobId}`, job);
       this.jobs.delete(jobId);
-    });
+    };
+
+    if (options.delay && options.delay > 0) {
+      job.status = 'delayed';
+      job.timeoutHandle = setTimeout(runHandler, options.delay);
+    } else {
+      setImmediate(runHandler);
+    }
 
     return jobId;
   }
@@ -63,7 +81,11 @@ class LocalQueueAdapter extends QueueAdapter {
 
   async cancelJob(jobId) {
     const job = this.jobs.get(jobId);
-    if (!job || job.status !== 'pending') return false;
+    if (!job || (job.status !== 'pending' && job.status !== 'delayed')) return false;
+    if (job.timeoutHandle) {
+      clearTimeout(job.timeoutHandle);
+      job.timeoutHandle = null;
+    }
     job.status = 'cancelled';
     this.events.emit(`job:${jobId}`, job);
     this.jobs.delete(jobId);
@@ -95,6 +117,12 @@ class LocalQueueAdapter extends QueueAdapter {
   }
 
   async shutdown() {
+    for (const job of this.jobs.values()) {
+      if (job.timeoutHandle) {
+        clearTimeout(job.timeoutHandle);
+        job.timeoutHandle = null;
+      }
+    }
     this.jobs.clear();
     this.handlers.clear();
     this.events.removeAllListeners();

package/package.json

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