@peopl-health/nexus 4.5.22 → 4.5.26

package/lib/adapters/TwilioProvider.js

@@ -9,6 +9,7 @@ const { generatePresignedUrl } = require('../config/awsConfig');
 const { sanitizeMediaFilename } = require('../utils/sanitizerUtils');
 const { validateMedia, getMediaType, MEDIA_LIMITS, STICKER_DIMENSIONS } = require('../utils/mediaValidator');
 const { logger } = require('../utils/logger');
+const { isJsonBlob } = require('../utils/formatUtils');
 const { calculateDelay } = require('../utils/scheduleUtils');
 const { isBenchMode } = require('../utils/benchModeHelper');
 
@@ -107,6 +108,13 @@ class TwilioProvider extends MessageProvider {
         messageParams.contentVariables = JSON.stringify(formattedVariables);
       }
     } else if (body) {
+      if (isJsonBlob(body)) {
+        logger.error('[TwilioProvider] Blocked raw JSON body from being sent to patient', {
+          code: formattedCode,
+          preview: body.slice(0, 120)
+        });
+        throw new Error('Refusing to send raw JSON as message body');
+      }
       messageParams.body = body;
     }
 

package/lib/core/AssistantProcessor.js

@@ -20,9 +20,9 @@ class AssistantProcessor {
     return { thread, assistant };
   }
 
-  async executeLLM(thread, assistant, runOptions = {}, messages = null) {
+  async executeLLM(thread, assistant, runOptions = {}, message = null) {
     const startTime = Date.now();
-    const runResult = await runAssistantWithRetries(thread, assistant, { ...runOptions, phiProcessor: this.phiProcessor }, messages);
+    const runResult = await runAssistantWithRetries(thread, assistant, { ...runOptions, phiProcessor: this.phiProcessor }, message);
     const predictionTimeMs = Date.now() - startTime;
 
     const output = sanitizeOutput(runResult?.output);
@@ -41,19 +41,19 @@ class AssistantProcessor {
     };
   }
 
-  async process({ code, runOptions = {}, messages = null }) {
+  async process({ code, runOptions = {}, message = null }) {
     if (!code) throw new Error('code is required for assistant processing');
 
     return (this.mode === 'queue')
       ? await this._executeViaQueue({ code, runOptions })
-      : await this._executeLocal({ code, runOptions, messages });
+      : await this._executeLocal({ code, runOptions, message });
   }
 
-  async _executeLocal({ code, runOptions = {}, messages = null }) {
+  async _executeLocal({ code, runOptions = {}, message = null }) {
     const resolved = await this.resolveThread(code);
     if (!resolved) return null;
 
-    const result = await this.executeLLM(resolved.thread, resolved.assistant, runOptions, messages);
+    const result = await this.executeLLM(resolved.thread, resolved.assistant, runOptions, message);
     if (this.storeRunMetrics) await this.storeRunMetrics(code, resolved.thread, result);
     return result;
   }

package/lib/core/NexusMessaging.js

@@ -507,7 +507,7 @@ class NexusMessaging {
           const result = await this.assistantProcessor.executeLLM(
             resolved.thread, resolved.assistant,
             { prePromptResult: preProcessResult },
-            preProcessed.messages
+            preProcessed.messages[0]
           );
 
           if (storeRunMetrics) await storeRunMetrics(chatId, resolved.thread, result, preProcessed.timings);

package/lib/helpers/assistantHelper.js

@@ -22,14 +22,17 @@ const runAssistantAndWait = async ({ thread, assistant, message = null, runConfi
     throw new Error('runAssistantAndWait requires thread and assistant');
   }
 
+  if (Array.isArray(message)) {
+    throw new Error('runAssistantAndWait requires message to be a single element, not an array');
+  }
+
   const variant = getProviderVariant();
   const provider = createLLMProvider({ variant });
   const { polling, tools: configTools, ...config } = runConfig;
   const tools = assistant.getToolSchemas?.() || configTools || [];
-  const messageForRun = Array.isArray(message) && message.length > 0 ? message[0] : message;
 
   return withThreadRecovery(
-    (currentThread = thread) => provider.executeRun({ thread: currentThread, message: messageForRun, assistant, tools, config, polling }),
+    (currentThread = thread) => provider.executeRun({ thread: currentThread, message, assistant, tools, config, polling }),
     thread,
     variant
   );

package/lib/index.d.ts

@@ -595,7 +595,7 @@ declare module '@peopl-health/nexus' {
   export interface ProcessInput {
     code: string;
     runOptions?: Record<string, any>;
-    messages?: any[] | null;
+    message?: any | null;
   }
 
   export interface LLMResult {
@@ -614,7 +614,7 @@ declare module '@peopl-health/nexus' {
     constructor(config: AssistantProcessorConfig);
     setSendMessage(fn: AssistantProcessorConfig['sendMessage']): void;
     resolveThread(code: string): Promise<{ thread: any; assistant: any } | null>;
-    executeLLM(thread: any, assistant: any, runOptions?: Record<string, any>, messages?: any[]): Promise<LLMResult>;
+    executeLLM(thread: any, assistant: any, runOptions?: Record<string, any>, message?: any): Promise<LLMResult>;
     process(input: ProcessInput): Promise<LLMResult | null>;
     sendResponse(code: string, result: any): Promise<string | null>;
   }

package/lib/providers/OpenAIResponsesProvider.js

@@ -4,6 +4,7 @@ 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');
 
@@ -167,16 +168,31 @@ class OpenAIResponsesProvider {
     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) {
-        if (messageItems.length > 1) {
+        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 message items in response; keeping the first (likely OpenAI multi-output bug)', {
-            discarded: messageItems.length - 1,
+          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
@@ -186,11 +202,12 @@ class OpenAIResponsesProvider {
             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.`,
+              `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'}`
-            ].join('\n'),
+            ].filter(Boolean).join('\n'),
             severity: 'medium',
             status: 'Open',
             clasificacion: 'alucinaciones',
@@ -201,14 +218,7 @@ class OpenAIResponsesProvider {
           }).catch((err) => logger.warn('[OpenAIResponsesProvider] Bug report logger failed', { error: err.message }));
         }
 
-        const firstMessage = messageItems[0];
-        let text = '';
-        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();
+        if (proseTexts.length > 0) return proseTexts[0];
       }
     }
     if (result.output_text) return this._extractMessageFromConcatenatedOutput(result.output_text);

package/lib/utils/formatUtils.js

@@ -26,14 +26,27 @@ function formatForWhatsApp(text) {
 
 function sanitizeOutput(text) {
   if (!text || typeof text !== 'string') return text;
-  
+
   let sanitized = text;
   sanitized = removeBracketContent(sanitized);
   sanitized = formatForWhatsApp(sanitized);
-  
+
   return sanitized;
 }
 
-module.exports = { 
-  sanitizeOutput 
+function isJsonBlob(text) {
+  if (!text || typeof text !== 'string') return false;
+  const trimmed = text.trim();
+  if (!(trimmed.startsWith('{') || trimmed.startsWith('['))) return false;
+  try {
+    const parsed = JSON.parse(trimmed);
+    return parsed !== null && typeof parsed === 'object';
+  } catch {
+    return false;
+  }
+}
+
+module.exports = {
+  sanitizeOutput,
+  isJsonBlob
 };

package/package.json

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