@peopl-health/nexus 4.5.26 → 4.5.28

package/lib/adapters/MessageAdapter.js

@@ -15,12 +15,6 @@ class MessageAdapter {
     case 'list':
       return interactive.title || interactive.description || '[List item selected]';
     case 'flow':
-      if (interactive.data) {
-        const flowData = typeof interactive.data === 'string'
-          ? interactive.data
-          : JSON.stringify(interactive.data, null, 2);
-        return `Flow Response:\n${flowData}`;
-      }
       return '[Flow response]';
     default:
       return '[Interactive message]';

package/lib/controllers/conversationController.js

@@ -91,6 +91,7 @@ const getConversationMessagesController = async (req, res) => {
 
     const total = await countMessages(query);
     const messages = await getMessages(query, { sort: { createdAt: -1 }, skip, limit });
+    messages.forEach(msg => { msg.body = msg.plainBody || msg.body; });
     const totalPages = Math.ceil(total / limit);
 
     res.status(200).json({
@@ -207,7 +208,10 @@ const searchConversationsController = async (req, res) => {
           secondary: [
             { $match: {
               group_id: null,
-              body: { $regex: escapedQuery, $options: 'i' }
+              $or: [
+                { plainBody: { $regex: escapedQuery, $options: 'i' } },
+                { body: { $regex: escapedQuery, $options: 'i' } }
+              ]
             }},
             { $group: { _id: '$numero' } }
           ]
@@ -400,6 +404,7 @@ const getNewMessagesController = async (req, res) => {
     const raw = parseInt(req.query.limit, 10);
     const clampedLimit = Number.isFinite(raw) ? Math.min(Math.max(raw, 1), 100) : 20;
     const messages = await getMessages(query, { sort: { createdAt: 1 }, limit: clampedLimit });
+    messages.forEach(msg => { msg.body = msg.plainBody || msg.body; });
         
     res.status(200).json({
       success: true,
@@ -554,13 +559,17 @@ const searchMessagesByNumberController = async (req, res) => {
     const mongoQuery = {
       group_id: null,
       numero: formattedPhoneNumber,
-      body: { $regex: escapedQuery, $options: 'i' }
+      $or: [
+        { plainBody: { $regex: escapedQuery, $options: 'i' } },
+        { body: { $regex: escapedQuery, $options: 'i' } }
+      ]
     };
     
     const mongoSort = { createdAt: -1 };
 
     const total = await countMessages(mongoQuery);
     const messages = await getMessages(mongoQuery, { sort: mongoSort, skip, limit });
+    messages.forEach(msg => { msg.body = msg.plainBody || msg.body; });
     const totalPages = Math.ceil(total / limit);
 
     res.status(200).json({

package/lib/controllers/interactionController.js

@@ -15,7 +15,7 @@ async function logInteractionToAirtable(messageIds, whatsapp_id, reporter, quali
     const conversation = messageObjects.map(msg => {
       const timestamp = msg.createdAt.toISOString().slice(0, 16).replace('T', ' ');
       const role = msg.from_me ? 'Assistant' : 'Patient';
-      return `[${timestamp}] ${role}: ${msg.body || '(media)'}`;
+      return `[${timestamp}] ${role}: ${msg.plainBody || msg.body || '(media)'}`;
     }).join('\n');
 
     let patientId = null;

package/lib/controllers/templateController.js

@@ -232,7 +232,6 @@ const submitForApproval = async (req, res) => {
         status: 'PENDING',
         approvalRequest: {
           sid: response.sid,
-          status: response.status || 'PENDING',
           dateSubmitted: validSubmittedDate,
           dateUpdated: validUpdatedDate,
           rejectionReason: response.rejection_reason || ''
@@ -282,7 +281,6 @@ const checkApprovalStatus = async (req, res) => {
           );
           dbTemplate.approvalRequest = {
             sid: status.approvalRequest.sid,
-            status: status.approvalRequest.status,
             dateSubmitted,
             dateUpdated: parseDate(
               status.approvalRequest.date_updated || status.approvalRequest.dateUpdated || status.content.dateUpdated,

package/lib/core/MessageParser.js

@@ -8,17 +8,20 @@ class MessageParser {
     this.config = config;
     this.commandPrefixes = config.commandPrefixes || ['/', '!'];
     this.keywords = config.keywords || [];
-    this.flowTriggers = config.flowTriggers || [];
   }
 
   async parseMessage(normalizedMessage) {
     const {media, interactive, ...base} = normalizedMessage;
     await parsePatientInformation(base);
 
-    if (interactive) {
+    if (interactive && interactive.type !== 'flow') {
       return {...base, type: 'interactive', interactive, isInteractive: true};
     }
 
+    if (interactive && interactive.type === 'flow') {
+      return {...base, type: 'flow', flow: interactive, interactive};
+    }
+
     if (media) {
       return {...base, type: 'media', media, isMedia: true};
     }
@@ -38,11 +41,6 @@ class MessageParser {
       return {...base, type: 'keyword', keyword};
     }
 
-    const flow = this.findFlowTrigger(body);
-    if (flow) {
-      return {...base, type: 'flow', flow};
-    }
-
     return {...base, type: 'message'};
   }
 
@@ -76,15 +74,10 @@ class MessageParser {
     return this._findMatch(text, this.keywords);
   }
 
-  findFlowTrigger(text) {
-    return this._findMatch(text, this.flowTriggers);
-  }
-
   updateConfig(newConfig) {
     this.config = { ...this.config, ...newConfig };
     this.commandPrefixes = this.config.commandPrefixes || this.commandPrefixes;
     this.keywords = this.config.keywords || this.keywords;
-    this.flowTriggers = this.config.flowTriggers || this.flowTriggers;
   }
 }
 

package/lib/core/NexusMessaging.js

@@ -380,10 +380,10 @@ class NexusMessaging {
           if (stop) return;
         }
 
+        if (messageData.flow) return this.handleFlow(messageData);
         if (messageData.interactive) return this.handleInteractive(messageData);
         if (messageData.command) return this.handleCommand(messageData);
         if (messageData.keyword) return this.handleKeyword(messageData);
-        if (messageData.flow) return this.handleFlow(messageData);
 
         if (this.batchingConfig.enabled && chatId) return this._handleWithCheckAfter(chatId);
         return messageData.media ? this.handleMedia(messageData) : this.handleMessage(messageData);
@@ -415,6 +415,8 @@ class NexusMessaging {
 
   async handleFlow(messageData) {
     if (this.handlers.onFlow) return await this.handlers.onFlow(messageData, this);
+    // Backward compatibility for consumers who don't have onFlow handler
+    if (this.handlers.onInteractive) return await this.handlers.onInteractive(messageData, this);
   }
 
   /*
@@ -518,7 +520,6 @@ class NexusMessaging {
   }
 
   async processInstruction(code, instruction, role = 'developer', { triggeredBy } = {}) {
-    const assistantId = await this._getThreadAssistantId(code);
     const messageData = {
       pushName: 'Instruction',
       code,
@@ -527,7 +528,6 @@ class NexusMessaging {
       fromMe: true,
       processed: true,
       origin: 'instruction',
-      assistantId,
       raw: { role },
       triggeredBy: triggeredBy || null,
       silent: true,
@@ -556,7 +556,6 @@ class NexusMessaging {
     const thread = await Thread.findOne({ code }).lean();
     if (!thread) return null;
 
-    const assistantId = await this._getThreadAssistantId(code);
     const normalizedMessages = Array.isArray(messages) ? messages : [messages];
 
     for (let i = 0; i < normalizedMessages.length; i++) {
@@ -569,7 +568,6 @@ class NexusMessaging {
           fromMe: true,
           processed: true,
           origin: 'system',
-          assistantId,
           raw: { role },
           triggeredBy: triggeredBy || null,
           silent: true,
@@ -597,11 +595,6 @@ class NexusMessaging {
     return result?.output || null;
   }
 
-  async _getThreadAssistantId(code) {
-    const thread = await Thread.findOne({ code }).select('assistant_id prompt_id').lean();
-    return thread?.prompt_id || thread?.assistant_id || null;
-  }
-
   async _processMessages(chatId, processingFn, shouldFinalize = () => true) {
     const query = { numero: chatId, from_me: false, processed: false };
     const unprocessed = await getMessages(query, { select: '_id' });

package/lib/core/PhiProcessor.js

@@ -69,16 +69,18 @@ class PhiProcessor {
   }
 
   async inData(messageData, saveFn, handler) {
-    const encoded = await this.encodeBody(messageData.body, messageData.code);
-    const saved = await saveFn({ ...messageData, body: encoded });
-    return handler({ body: encoded, _id: saved?._id });
+    const decodedBody = messageData.body;
+    const encodedBody = await this.encodeBody(decodedBody, messageData.code);
+    const saved = await saveFn({ ...messageData, body: encodedBody, plainBody: decodedBody });
+    return handler({ body: encodedBody, _id: saved?._id });
   }
 
   async outDataFromPlain(messageData, saveFn, handler, { onSaved } = {}) {
-    const encoded = await this.encodeBody(messageData.body, messageData.code);
-    const saved = await saveFn({ ...messageData, body: encoded });
+    const decodedBody = messageData.body;
+    const encodedBody = await this.encodeBody(decodedBody, messageData.code);
+    const saved = await saveFn({ ...messageData, body: encodedBody, plainBody: decodedBody });
     await onSaved?.(saved?._id);
-    return handler({ body: messageData.body, _id: saved?._id });
+    return handler({ body: decodedBody, _id: saved?._id });
   }
 
   async decodeBody(body, numero) {
@@ -100,10 +102,10 @@ class PhiProcessor {
   }
 
   async outDataFromEncoded(messageData, saveFn, handler) {
-    const saved = await saveFn(messageData);
     const decodedBody = this._phiEnabled
       ? await this.decodeBody(messageData.body, messageData.code)
       : messageData.body;
+    const saved = await saveFn({ ...messageData, plainBody: decodedBody });
     return handler({ body: decodedBody, _id: saved?._id });
   }
 }

package/lib/helpers/messageHelper.js

@@ -90,7 +90,9 @@ async function getLastNMessages(code, n, anchor = null, opts = {}) {
     numero: code,
     ...(anchor ? { createdAt: { [beforeOperator]: anchor } } : {}),
   };
-  return getMessages(query, { sort: { createdAt: -1 }, limit: n });
+  const messages = await getMessages(query, { sort: { createdAt: -1 }, limit: n });
+  messages.forEach(msg => { msg.body = msg.plainBody || msg.body; });
+  return messages;
 }
 
 module.exports = {

package/lib/index.d.ts

@@ -13,7 +13,7 @@ declare module '@peopl-health/nexus' {
     media?: MediaData;
     command?: CommandData;
     keyword?: string;
-    flow?: string;
+    flow?: InteractiveData;
     type?: 'message' | 'interactive' | 'media' | 'command' | 'keyword' | 'flow';
   }
 
@@ -93,7 +93,6 @@ declare module '@peopl-health/nexus' {
   export interface ParserConfig {
     commandPrefixes?: string[];
     keywords?: (string | { pattern: string; flags?: string })[];
-    flowTriggers?: (string | { pattern: string; flags?: string })[];
   }
 
   // Handler Types

package/lib/models/messageModel.js

@@ -5,6 +5,7 @@ const { DELIVERY_ATTEMPT_STATUSES } = require('./deliveryAttemptModel');
 const messageSchema = new mongoose.Schema({
   raw: { type: Object, default: null },
   body: { type: String, default: '' },
+  plainBody: { type: String, default: null },
   numero: { type: String, required: true },
   nombre_whatsapp: { type: String, default: null },
   message_id: { type: String, default: null},

package/lib/models/templateModel.js

@@ -37,7 +37,6 @@ const TemplateSchema = new mongoose.Schema({
   ],
   approvalRequest: {
     sid: String,
-    status: String,
     dateSubmitted: Date,
     dateUpdated: Date,
     rejectionReason: String

package/lib/providers/BaseLLMProvider.js

@@ -0,0 +1,275 @@
+const runtimeConfig = require('../config/runtimeConfig');
+const { logger } = require('../utils/logger');
+const { getCurrentMexicoDateTime } = require('../utils/dateUtils');
+const { isJsonBlob } = require('../utils/formatUtils');
+
+const { DefaultMemoryManager } = require('../memory/DefaultMemoryManager');
+
+const { getMessages } = require('../services/messageService');
+
+const { logBugReportToAirtable } = require('../controllers/bugReportController');
+
+const DEFAULT_MAX_CONVERSATION_RETRIES = 3;
+
+class BaseLLMProvider {
+  constructor(options = {}) {
+    if (new.target === BaseLLMProvider) {
+      throw new Error('BaseLLMProvider is abstract and cannot be instantiated directly');
+    }
+    const { conversationManager, sessionManager, maxConversationRetries } = options;
+    this.client = null;
+    this.variant = null;
+    this.conversationManager = conversationManager || new DefaultMemoryManager();
+    this.sessionManager = sessionManager || null;
+    const retries = parseInt(maxConversationRetries, 10);
+    this.maxConversationRetries = retries > 0 ? retries : DEFAULT_MAX_CONVERSATION_RETRIES;
+  }
+
+  getVariant() { return this.variant; }
+  getClient() { return this.client; }
+
+  async _executeConversation() {
+    throw new Error(`${this.constructor.name} must implement _executeConversation()`);
+  }
+
+  async createConversation() {
+    throw new Error(`createConversation is not supported by ${this.constructor.name}`);
+  }
+
+  async addMessage() {
+    throw new Error(`addMessage is not supported by ${this.constructor.name}`);
+  }
+
+  async listMessages() {
+    throw new Error(`listMessages is not supported by ${this.constructor.name}`);
+  }
+
+  async transcribeAudio() {
+    throw new Error(`transcribeAudio is not supported by ${this.constructor.name}`);
+  }
+
+  async executeRun({ thread, assistant, message = null, tools = [], config = {} }) {
+    const { conversationId, assistantId } = this._normalizeThread(thread);
+    const promptVersion = thread?.version || null;
+    const presetId = thread?.preset_id || null;
+    const presetVersion = thread?.preset_version || null;
+
+    logger.info('[executeRun] Starting', { conversationId, assistantId, promptVersion });
+
+    try {
+      const context = await this.conversationManager.buildContext({
+        thread,
+        message,
+        config: {
+          ...config,
+          threadId: conversationId,
+          assistantId,
+        }
+      });
+
+      const [lastMessage] = await getMessages({ numero: thread.code }, { sort: { createdAt: -1 }, limit: 1 });
+      const phiProcessor = config.phiProcessor;
+      const maskedCode = phiProcessor ? phiProcessor.hashCode(thread.code) : thread.code;
+      const metadata = {
+        numero: maskedCode,
+        message_id: message?.message_id || lastMessage?.message_id || null
+      };
+
+      logger.info('[executeRun] Context built', { conversationId, messageCount: context?.length || 0 });
+
+      const override = config.clinicalData;
+      const hasOverride = override && typeof override === 'object' && Object.keys(override).length > 0;
+      const clinicalData = hasOverride ? override : await this.conversationManager.getClinicalData(thread.code);
+      const promptVariables = {
+        clinical_context: clinicalData?.clinicalContext ?? '',
+        last_symptoms: clinicalData?.lastSymptoms ?? '',
+        current_date: getCurrentMexicoDateTime(),
+        patient_memories: clinicalData?.patientMemories ?? '',
+        conversation_summaries: clinicalData?.conversationSummaries ?? '',
+      };
+
+      const result = await this.runConversation({
+        threadId: conversationId,
+        assistantId,
+        presetId,
+        presetVersion,
+        tools,
+        context,
+        promptVariables,
+        promptVersion,
+        assistant,
+        metadata,
+        ...config
+      });
+
+      await this.conversationManager.processResponse(result, thread, config);
+      this.sessionManager?.recordActivity(thread.code);
+
+      const completed = result.status === 'completed';
+      const output = result.output_text || this._extractMessageOutput(result);
+      const toolsExecuted = result.tools_executed?.length || 0;
+
+      logger.info('[executeRun] Complete', {
+        runId: result.id,
+        completed,
+        outputLength: output?.length || 0,
+        toolsExecuted
+      });
+
+      return { run: result, completed, output, tools_executed: result.tools_executed || [], retries: result.retries || 0 };
+    } catch (error) {
+      logger.error('[executeRun] Failed', { conversationId, assistantId, error: error.message });
+      throw error;
+    }
+  }
+
+  async runConversation(config = {}) {
+    const { threadId, assistantId } = config;
+    const maxRetries = this.maxConversationRetries;
+
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        logger.info('[runConversation] Attempt', { attempt, maxRetries, threadId, assistantId });
+
+        const result = await this._executeConversation(config);
+        const extractedOutput = this._extractMessageOutput(result);
+
+        if (extractedOutput?.trim()) {
+          result.output_text = extractedOutput;
+          logger.info('[runConversation] Success', {
+            attempt,
+            outputLength: extractedOutput.length,
+            toolsExecuted: result.tools_executed?.length || 0
+          });
+          return result;
+        }
+
+        logger.warn('[runConversation] Empty output', { attempt });
+        if (attempt === maxRetries) {
+          throw new Error(`Conversation failed after ${attempt} attempts - no valid output`);
+        }
+        await new Promise(r => setTimeout(r, 500));
+      } catch (error) {
+        logger.error('[runConversation] Attempt failed', { attempt, error: error.message });
+        if (attempt === maxRetries) throw error;
+        await new Promise(r => setTimeout(r, 500));
+      }
+    }
+  }
+
+  _normalizeThread(thread) {
+    return {
+      conversationId: thread.conversation_id || thread.getConversationId?.(),
+      assistantId: thread.prompt_id || thread.getAssistantId?.()
+    };
+  }
+
+  _convertItemsToApiFormat(items) {
+    return items.map(item => {
+      const type = item.type || 'message';
+      if (type === 'function_call' || type === 'function_call_output') {
+        return { ...item, type };
+      }
+      return {
+        role: item.role || 'user',
+        type,
+        content: this._normalizeContent(item.content)
+      };
+    });
+  }
+
+  _normalizeContent(content) {
+    if (typeof content === 'string') return content;
+    if (Array.isArray(content)) return content;
+    if (content?.text) return content.text;
+    if (content && typeof content === 'object') return JSON.stringify(content);
+    return content || '';
+  }
+
+  _contentPartToText(part) {
+    if (part == null || typeof part !== 'object') return '';
+    return typeof part.text === 'string' ? part.text : (typeof part.text?.value === 'string' ? part.text.value : '');
+  }
+
+  _messageItemToText(item) {
+    if (!item) return '';
+    if (Array.isArray(item.content)) {
+      return item.content.map(c => this._contentPartToText(c)).filter(Boolean).join('').trim();
+    }
+    if (typeof item.content === 'string') return item.content.trim();
+    return '';
+  }
+
+  _extractMessageOutput(result) {
+    if (result == null || typeof result !== 'object') return '';
+
+    if (result.output && Array.isArray(result.output)) {
+      const messageItems = result.output.filter(item => item && item.type === 'message');
+      if (messageItems.length > 0) {
+        const texts = messageItems.map(item => this._messageItemToText(item)).filter(Boolean);
+        const proseTexts = texts.filter(text => !isJsonBlob(text));
+        const jsonDiscarded = texts.length - proseTexts.length;
+        const keptOne = proseTexts.length > 0 ? 1 : 0;
+
+        if (messageItems.length > 1 || jsonDiscarded > 0) {
+          const hasFunctionCalls = result.output.some(item => item?.type === 'function_call');
+          logger.warn(`[${this.constructor.name}] Multiple/structured message items in response; keeping the first natural-language reply (likely OpenAI multi-output bug)`, {
+            discarded: messageItems.length - keptOne,
+            jsonDiscarded,
+            responseId: result.id,
+            model: result.model,
+            hasFunctionCalls
+          });
+          logBugReportToAirtable({
+            reporter: 'system',
+            description: [
+              `Responses API (${this.constructor.name}) returned multiple message items in a single response.`,
+              'Suspected upstream bug (model failed to emit stop-of-message token).',
+              `Discarded ${messageItems.length - keptOne} extra message(s); kept the first natural-language reply as the canonical reply.`,
+              jsonDiscarded > 0 ? `${jsonDiscarded} discarded item(s) were raw JSON/structured output that must never reach the patient.` : null,
+              `Response ID: ${result.id || 'unknown'}`,
+              `Model: ${result.model || 'unknown'}`,
+              `Function calls present: ${hasFunctionCalls ? 'yes' : 'no'}`
+            ].filter(Boolean).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(`[${this.constructor.name}] Bug report logger failed`, { error: err.message }));
+        }
+
+        if (proseTexts.length > 0) return proseTexts[0];
+      }
+    }
+    if (result.output_text) return this._extractMessageFromConcatenatedOutput(result.output_text);
+    return '';
+  }
+
+  _extractMessageFromConcatenatedOutput(outputText) {
+    if (!outputText || typeof outputText !== 'string') return '';
+    if (!/^\s*assistant\s*\n/i.test(outputText)) return outputText.trim();
+
+    const segments = outputText
+      .split(/\n\s*assistant\s*\n/i)
+      .map(s => s.replace(/^assistant\s*\n?/i, '').trim())
+      .filter(Boolean);
+
+    if (segments.length === 0) return '';
+    if (segments.length > 1) logger.debug(`[${this.constructor.name}] Concatenated transcript detected, using last segment`, { segmentCount: segments.length });
+    return segments[segments.length - 1].trim();
+  }
+
+  _ensureId(value) {
+    if (!value) throw new Error('Identifier value is required');
+    if (typeof value === 'string') return value;
+    if (value?.id) return value.id;
+    throw new Error('Unable to resolve identifier value');
+  }
+}
+
+module.exports = {
+  BaseLLMProvider,
+};

package/lib/providers/OpenAIResponsesProvider.js

@@ -1,18 +1,12 @@
 const { OpenAI } = require('openai');
 
-const runtimeConfig = require('../config/runtimeConfig');
 const { retryWithBackoff } = require('../utils/retryUtils');
 const { logger } = require('../utils/logger');
-const { getCurrentMexicoDateTime } = require('../utils/dateUtils');
-const { isJsonBlob } = require('../utils/formatUtils');
-
-const { DefaultMemoryManager } = require('../memory/DefaultMemoryManager');
 
 const { composePrompt, resolveTools } = require('../services/promptComposerService');
 const { getToolSchemas: getRegistrySchemas } = require('../services/toolRegistryService');
-const { getMessages } = require('../services/messageService');
 
-const { logBugReportToAirtable } = require('../controllers/bugReportController');
+const { BaseLLMProvider } = require('./BaseLLMProvider');
 const { handleFunctionCalls } = require('./OpenAIResponsesProviderTools');
 
 const CONVERSATION_PREFIX = 'conv_';
@@ -20,19 +14,17 @@ const RESPONSE_PREFIX = 'resp_';
 const MAX_ITEMS_ON_CREATE = 20;
 const MAX_ITEMS_PER_BATCH = 20;
 const DEFAULT_MAX_HISTORICAL_MESSAGES = parseInt(process.env.MAX_HISTORICAL_MESSAGES || '50', 10);
-const MAX_CONVERSATION_RETRIES = parseInt(process.env.MAX_CONVERSATION_RETRIES || '3', 10);
 const MAX_FUNCTION_ROUNDS = parseInt(process.env.MAX_FUNCTION_ROUNDS || '5', 10);
 const PROVIDER_NAME = 'OpenAIResponsesProvider';
 
-class OpenAIResponsesProvider {
+class OpenAIResponsesProvider extends BaseLLMProvider {
   constructor(options = {}) {
+    super(options);
     const {
       apiKey = process.env.OPENAI_API_KEY,
       organization,
       client,
       defaultModels = {},
-      conversationManager,
-      sessionManager,
     } = options;
 
     if (!client && !apiKey) {
@@ -51,16 +43,11 @@ class OpenAIResponsesProvider {
     };
 
     this.variant = 'responses';
-    this.conversationManager = conversationManager || new DefaultMemoryManager();
-    this.sessionManager = sessionManager || null;
 
     this.responses = this.client.responses;
     this.conversations = this.client.conversations;
   }
 
-  getVariant() { return this.variant; }
-  getClient() { return this.client; }
-
   async createConversation({ metadata, messages = [], toolResources } = {}) {
     const capped = messages.length > DEFAULT_MAX_HISTORICAL_MESSAGES;
     const messagesToProcess = capped ? messages.slice(-DEFAULT_MAX_HISTORICAL_MESSAGES) : messages;
@@ -116,28 +103,6 @@ class OpenAIResponsesProvider {
     logger.info(`[_addItemsInBatches] Added ${items.length} messages in ${Math.ceil(items.length / batchSize)} batches`);
   }
 
-  _convertItemsToApiFormat(items) {
-    return items.map(item => {
-      const type = item.type || 'message';
-      if (type === 'function_call' || type === 'function_call_output') {
-        return { ...item, type };
-      }
-      return {
-        role: item.role || 'user',
-        type,
-        content: this._normalizeContent(item.content)
-      };
-    });
-  }
-
-  _normalizeContent(content) {
-    if (typeof content === 'string') return content;
-    if (Array.isArray(content)) return content;
-    if (content?.text) return content.text;
-    if (content && typeof content === 'object') return JSON.stringify(content);
-    return content || '';
-  }
-
   async addMessage({ threadId, messages, role = 'user', content, metadata }) {
     const id = this._ensurethreadId(threadId);
     const messagesToAdd = messages || [{ role, content, metadata }];
@@ -156,199 +121,6 @@ class OpenAIResponsesProvider {
     );
   }
 
-  _normalizeThread(thread) {
-    return {
-      conversationId: thread.conversation_id || thread.getConversationId?.(),
-      assistantId: thread.prompt_id || thread.getAssistantId?.()
-    };
-  }
-
-  _contentPartToText(part) {
-    if (part == null || typeof part !== 'object') return '';
-    return typeof part.text === 'string' ? part.text : (typeof part.text?.value === 'string' ? part.text.value : '');
-  }
-
-  _messageItemToText(item) {
-    if (!item) return '';
-    if (Array.isArray(item.content)) {
-      return item.content.map(c => this._contentPartToText(c)).filter(Boolean).join('').trim();
-    }
-    if (typeof item.content === 'string') return item.content.trim();
-    return '';
-  }
-
-  _extractMessageOutput(result) {
-    if (result == null || typeof result !== 'object') return '';
-
-    if (result.output && Array.isArray(result.output)) {
-      const messageItems = result.output.filter(item => item && item.type === 'message');
-      if (messageItems.length > 0) {
-        const texts = messageItems.map(item => this._messageItemToText(item)).filter(Boolean);
-        const proseTexts = texts.filter(text => !isJsonBlob(text));
-        const jsonDiscarded = texts.length - proseTexts.length;
-        const keptOne = proseTexts.length > 0 ? 1 : 0;
-
-        if (messageItems.length > 1 || jsonDiscarded > 0) {
-          const hasFunctionCalls = result.output.some(item => item?.type === 'function_call');
-          logger.warn('[OpenAIResponsesProvider] Multiple/structured message items in response; keeping the first natural-language reply (likely OpenAI multi-output bug)', {
-            discarded: messageItems.length - keptOne,
-            jsonDiscarded,
-            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 - keptOne} extra message(s); kept the first natural-language reply as the canonical reply.`,
-              jsonDiscarded > 0 ? `${jsonDiscarded} discarded item(s) were raw JSON/structured output that must never reach the patient.` : null,
-              `Response ID: ${result.id || 'unknown'}`,
-              `Model: ${result.model || 'unknown'}`,
-              `Function calls present: ${hasFunctionCalls ? 'yes' : 'no'}`
-            ].filter(Boolean).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 }));
-        }
-
-        if (proseTexts.length > 0) return proseTexts[0];
-      }
-    }
-    if (result.output_text) return this._extractMessageFromConcatenatedOutput(result.output_text);
-    return '';
-  }
-
-  _extractMessageFromConcatenatedOutput(outputText) {
-    if (!outputText || typeof outputText !== 'string') return '';
-    if (!/^\s*assistant\s*\n/i.test(outputText)) return outputText.trim();
-
-    const segments = outputText
-      .split(/\n\s*assistant\s*\n/i)
-      .map(s => s.replace(/^assistant\s*\n?/i, '').trim())
-      .filter(Boolean);
-
-    if (segments.length === 0) return '';
-    if (segments.length > 1) logger.debug('[OpenAIResponsesProvider] Concatenated transcript detected, using last segment', { segmentCount: segments.length });
-    return segments[segments.length - 1].trim();
-  }
-
-  async executeRun({ thread, assistant, message = null, tools = [], config = {} }) {
-    const { conversationId, assistantId } = this._normalizeThread(thread);
-    const promptVersion = thread?.version || null;
-    const presetId = thread?.preset_id || null;
-    const presetVersion = thread?.preset_version || null;
-
-    logger.info('[executeRun] Starting', { conversationId, assistantId, promptVersion });
-
-    try {
-      const context = await this.conversationManager.buildContext({
-        thread,
-        message,
-        config: {
-          ...config,
-          threadId: conversationId,
-          assistantId,
-        }
-      });
-
-      const [lastMessage] = await getMessages({ numero: thread.code }, { sort: { createdAt: -1 }, limit: 1 });
-      const phiProcessor = config.phiProcessor;
-      const maskedCode = phiProcessor ? phiProcessor.hashCode(thread.code) : thread.code;
-      const metadata = {
-        numero: maskedCode,
-        message_id: message?.message_id || lastMessage?.message_id || null
-      };
-
-      logger.info('[executeRun] Context built', { conversationId, messageCount: context?.length || 0 });
-
-      // config.clinicalData, when given, fully replaces the fetched bundle (all four fields).
-      // Must be a complete, non-empty object; anything else falls through to the normal fetch.
-      const override = config.clinicalData;
-      const hasOverride = override && typeof override === 'object' && Object.keys(override).length > 0;
-      const clinicalData = hasOverride ? override : await this.conversationManager.getClinicalData(thread.code);
-      const promptVariables = {
-        clinical_context: clinicalData?.clinicalContext ?? '',
-        last_symptoms: clinicalData?.lastSymptoms ?? '',
-        current_date: getCurrentMexicoDateTime(),
-        patient_memories: clinicalData?.patientMemories ?? '',
-        conversation_summaries: clinicalData?.conversationSummaries ?? '',
-      };
-
-      const result = await this.runConversation({
-        threadId: conversationId,
-        assistantId,
-        presetId,
-        presetVersion,
-        tools,
-        context,
-        promptVariables,
-        promptVersion,
-        assistant,
-        metadata,
-        ...config
-      });
-
-      await this.conversationManager.processResponse(result, thread, config);
-      this.sessionManager?.recordActivity(thread.code);
-
-      const completed = result.status === 'completed';
-      const output = result.output_text || this._extractMessageOutput(result);
-      const toolsExecuted = result.tools_executed?.length || 0;
-
-      logger.info('[executeRun] Complete', {
-        runId: result.id,
-        completed,
-        outputLength: output?.length || 0,
-        toolsExecuted
-      });
-
-      return { run: result, completed, output, tools_executed: result.tools_executed || [], retries: result.retries || 0 };
-    } catch (error) {
-      logger.error('[executeRun] Failed', { conversationId, assistantId, error: error.message });
-      throw error;
-    }
-  }
-
-  async runConversation(config = {}) {
-    const { threadId, assistantId } = config;
-
-    for (let attempt = 1; attempt <= MAX_CONVERSATION_RETRIES; attempt++) {
-      try {
-        logger.info('[runConversation] Attempt', { attempt, maxRetries: MAX_CONVERSATION_RETRIES, threadId, assistantId });
-
-        const result = await this._executeConversation(config);
-        const extractedOutput = this._extractMessageOutput(result);
-
-        if (extractedOutput?.trim()) {
-          result.output_text = extractedOutput;
-          logger.info('[runConversation] Success', { 
-            attempt,
-            outputLength: extractedOutput.length,
-            toolsExecuted: result.tools_executed?.length || 0
-          });
-          return result;
-        }
-
-        logger.warn('[runConversation] Empty output', { attempt });
-        if (attempt === MAX_CONVERSATION_RETRIES) {
-          throw new Error(`Conversation failed after ${attempt} attempts - no valid output`);
-        }
-        await new Promise(r => setTimeout(r, 500));
-      } catch (error) {
-        logger.error('[runConversation] Attempt failed', { attempt, error: error.message });
-        if (attempt === MAX_CONVERSATION_RETRIES) throw error;
-        await new Promise(r => setTimeout(r, 500));
-      }
-    }
-  }
-
   async _executeConversation(config = {}) {
     const {
       threadId, assistantId, presetId = null, presetVersion = null, additionalMessages = [], context = null,
@@ -471,7 +243,6 @@ class OpenAIResponsesProvider {
     if (assistant && response.output) {
       let currentInput = [...input];
 
-      // Follow-up calls always use the default tool_choice.
       apiCallConfig.tool_choice = toolChoice;
 
       for (let round = 1; round <= MAX_FUNCTION_ROUNDS; round++) {
@@ -532,13 +303,6 @@ class OpenAIResponsesProvider {
     return id;
   }
 
-  _ensureId(value) {
-    if (!value) throw new Error('Identifier value is required');
-    if (typeof value === 'string') return value;
-    if (value?.id) return value.id;
-    throw new Error('Unable to resolve identifier value');
-  }
-
   async _post(path, body, options = {}) { return this.client.post(path, { ...options, body }); }
   async _get(path, query, options = {}) { return this.client.get(path, { ...options, query }); }
   async _delete(path, options = {}) { return this.client.delete(path, options); }

package/lib/services/messageService.js

@@ -63,7 +63,7 @@ async function insertMessage(values) {
         {
           $set: {
             lastMessageAt: new Date(),
-            lastMessageBody: values.body || '',
+            lastMessageBody: values.plainBody || '',
             lastMessageFromMe: !!values.from_me,
             lastMessageMedia: values.media || null
           },
@@ -77,7 +77,7 @@ async function insertMessage(values) {
     }
 
     updateRecordByFilter(Monitoreo_ID, 'message_monitor', `{whatsapp_id} = "${values.numero}"`, {
-      ...(values.from_me ? { last_message_bot: values.body } : { last_message_patient: values.body, read: false }),
+      ...(values.from_me ? { last_message_bot: doc.plainBody } : { last_message_patient: doc.plainBody, read: false }),
       ...(values.from_me ? { last_message_bot_time: doc.createdAt.toISOString() } : { last_message_patient_time: doc.createdAt.toISOString() })
     }, values.numero).catch(err => logger.error('[MongoStorage] Failed to update message_monitor table', { numero: values.numero, error: err.message }));
 

package/lib/services/templateService.js

@@ -16,7 +16,6 @@ const refreshApprovalStatuses = async (templates) => {
           const updateFields = {
             approvalRequest: {
               sid: reqData.sid,
-              status: reqData.status,
               dateSubmitted: reqData.dateCreated ? new Date(reqData.dateCreated) : new Date(),
               dateUpdated: reqData.dateUpdated ? new Date(reqData.dateUpdated) : new Date(),
               rejectionReason: reqData.rejectionReason || ''

package/lib/storage/MongoStorage.js

@@ -89,7 +89,7 @@ class MongoStorage {
       code: doc.numero,
       name: doc.nombre_whatsapp,
       origin: doc.origin,
-      body: doc.body,
+      body: doc.plainBody,
       media: doc.media,
       type: doc.interactive_type ? 'interactive' : doc.media ? 'media' : 'message',
       triggeredBy: doc.triggeredBy,
@@ -106,6 +106,7 @@ class MongoStorage {
       nombre_whatsapp: messageData.pushName ?? (fromMe ? runtimeConfig.get('USER_DB_MONGO') : null),
       numero: ensureWhatsAppFormat(messageData.code),
       body: messageData.body || '',
+      plainBody: messageData.plainBody || '',
       processed: messageData.processed || false,
       message_id: messageId,
       interactive_type: messageData.interactive?.type || null,

package/package.json

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