@peopl-health/nexus 2.5.11 → 2.7.0

package/lib/providers/OpenAIResponsesProvider.js

@@ -3,9 +3,8 @@ const { Thread } = require('../models/threadModel');
 const { retryWithBackoff } = require('../utils/retryHelper');
 const {
   handleFunctionCalls: handleFunctionCallsUtil,
-  handlePendingFunctionCalls: handlePendingFunctionCallsUtil,
-  transformToolsForResponsesAPI: transformToolsForResponsesAPIUtil
 } = require('./OpenAIResponsesProviderTools');
+const { DefaultConversationManager } = require('../services/DefaultConversationManager');
 const { logger } = require('../utils/logger');
 
 const CONVERSATION_PREFIX = 'conv_';
@@ -25,6 +24,7 @@ class OpenAIResponsesProvider {
       organization,
       client,
       defaultModels = {},
+      conversationManager,
     } = options;
 
     if (!client && !apiKey) {
@@ -41,6 +41,7 @@ class OpenAIResponsesProvider {
     };
 
     this.variant = 'responses';
+    this.conversationManager = conversationManager || new DefaultConversationManager();
 
     this.responses = this.client.responses;
     this.conversations = this.client.conversations;
@@ -161,33 +162,6 @@ class OpenAIResponsesProvider {
     return await this.client.conversations.items.list(id, { order, limit });
   }
 
-  async cleanupOrphanedFunctionCalls(threadId, deleteAll = false) {
-    try {
-      const id = this._ensurethreadId(threadId);
-      const messages = await this.listMessages({ threadId: id, order: 'desc' });
-      const items = messages?.data || [];
-      
-      if (items.length === 0) return;
-
-      if (deleteAll) {
-        logger.info(`[OpenAIResponsesProvider] Deleting all ${items.length} items from conversation`);
-        await Promise.all(items.map(item => 
-          this.conversations.items.delete(item.id, {conversation_id: id})
-        ));
-        return;
-      }
-
-      const outputCallIds = new Set(items.filter(i => i.type === 'function_call_output').map(o => o.call_id));
-      const orphanedCalls = items.filter(i => i.type === 'function_call' && !outputCallIds.has(i.call_id));
-      
-      if (orphanedCalls.length > 0) {
-        await Promise.all(orphanedCalls.map(call => this.conversations.items.delete(call.id, {conversation_id: id})));
-      }
-    } catch (error) {
-      logger.warn('[OpenAIResponsesProvider] Failed to cleanup conversation:', error?.message);
-    }
-  }
-
   _normalizeThread(thread) {
     return {
       conversationId: thread.conversation_id || thread.getConversationId?.(),
@@ -200,107 +174,138 @@ class OpenAIResponsesProvider {
    */
   async executeRun({ thread, assistant, tools = [], config = {} }) {
     const { conversationId, assistantId } = this._normalizeThread(thread);
-    const preparedConfig = {
-      ...config,
-      assistant,
-      toolMetadata: {
-        numero: thread.code,
-        assistant_id: assistantId
-      }
-    };
-
+    
     logger.info('[OpenAIResponsesProvider] Starting run', {
       conversationId,
       assistantId
     });
 
-    const filter = thread.code ? { code: thread.code, active: true } : null;
-    const result = await this.runConversation({
-      threadId: conversationId,
-      assistantId,
-      tools,
-      ...preparedConfig
-    });
-
-    const completed = result.status === 'completed';
-    const output = await this.getRunText({ 
-      runId: result.id, 
-      fallback: '' 
-    });
+    try {
+      // Delegate context building to conversation manager
+      const context = await this.conversationManager.buildContext({
+        thread,
+        assistant,
+        config: {
+          ...config,
+          threadId: conversationId,
+          assistantId,
+          toolMetadata: {
+            numero: thread.code,
+            assistant_id: assistantId
+          }
+        }
+      });
 
-    if (filter) {
-      await Thread.updateOne(filter, { $set: { run_id: null } });
-    }
+      const filter = thread.code ? { code: thread.code, active: true } : null;
+      
+      // Get clinical context for prompt variables
+      const clinicalData = await this.conversationManager.getClinicalData(thread.code);
+      const promptVariables = clinicalData ? {
+        clinical_context: clinicalData.clinicalContext || '',
+        last_symptoms: clinicalData.lastSymptoms || ''
+      } : null;
+
+      // Execute with built context
+      const result = await this.runConversation({
+        threadId: conversationId,
+        assistantId,
+        tools,
+        context,
+        promptVariables,
+        assistant,
+        ...config
+      });
+
+      // Delegate response processing to conversation manager
+      await this.conversationManager.processResponse(result, thread, config);
+
+      const completed = result.status === 'completed';
+      const output = await this.getRunText({ 
+        runId: result.id, 
+        fallback: '' 
+      });
+
+      if (filter) {
+        await Thread.updateOne(filter, { $set: { run_id: null } });
+      }
 
-    logger.info('[OpenAIResponsesProvider] Run complete', {
-      runId: result.id,
-      completed,
-      toolsExecuted: result.tools_executed?.length || 0
-    });
+      logger.info('[OpenAIResponsesProvider] Run complete', {
+        runId: result.id,
+        completed,
+        toolsExecuted: result.tools_executed?.length || 0
+      });
 
-    return {
-      run: result,
-      completed,
-      output,
-      tools_executed: result.tools_executed || [],
-      retries: result.retries || 0
-    };
+      return {
+        run: result,
+        completed,
+        output,
+        tools_executed: result.tools_executed || [],
+        retries: result.retries || 0
+      };
+      
+    } catch (error) {
+      logger.error('[OpenAIResponsesProvider] Execute run failed', {
+        conversationId,
+        assistantId,
+        error: error.message
+      });
+      throw error;
+    }
   }
 
   async runConversation({
     threadId,
     assistantId,
     additionalMessages = [],
+    context = null,
     instructions = null,
     additionalInstructions = null,
-    toolOutputs = [],
     metadata = {},
     topP,
     temperature,
     maxOutputTokens,
     truncationStrategy = 'auto',
-    tools = [],
     model,
     assistant,
     toolMetadata,
+    promptVariables = null,
   } = {}) {
     try {
       const id = this._ensurethreadId(threadId);
-      let input = this._convertItemsToApiFormat(additionalMessages);
+      
+      let input = context || this._convertItemsToApiFormat(additionalMessages);
       let allToolsExecuted = [];
       let totalRetries = 0;
       
-      // Handle pending function calls
-      if (assistant && toolOutputs.length === 0) {
-        const conversationMessages = await this.listMessages({ threadId: id, order: 'desc', limit: 50 });
-        const result = await handlePendingFunctionCallsUtil(assistant, conversationMessages?.data || [], toolMetadata || { thread_id: id, assistant_id: assistantId });
-        toolOutputs = result.outputs || [];
-        allToolsExecuted = result.toolsExecuted || [];
-      }
+      input = input.filter(item => item.type !== 'function_call' && item.type !== 'function_call_output');
+
+      const promptConfig = promptVariables 
+        ? { id: assistantId, variables: promptVariables }
+        : { id: assistantId };
+      logger.info('[OpenAIResponsesProvider] Prompt config', { promptConfig });
 
-      input = [...input, ...toolOutputs];
       const makeAPICall = (inputData) => retryWithBackoff(() => 
         this.client.responses.create({
-          conversation: id,
-          prompt: { id: assistantId },
+          prompt: promptConfig,
           model: model || this.defaults.responseModel,
           instructions: additionalInstructions || instructions,
           input: inputData,
           metadata, top_p: topP, temperature, max_output_tokens: maxOutputTokens,
           truncation: truncationStrategy,
-          tools: transformToolsForResponsesAPIUtil(this.variant, tools),
         }), { providerName: PROVIDER_NAME });
 
       const { result: response, retries } = await makeAPICall(input);
       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');
         
         if (functionCalls.length > 0) {
           const { outputs, toolsExecuted } = await handleFunctionCallsUtil(functionCalls, assistant, toolMetadata || { thread_id: id, assistant_id: assistantId });
           
+          input.push(...response.output);
           input.push(...outputs);
           allToolsExecuted.push(...toolsExecuted);
 

package/lib/providers/OpenAIResponsesProviderTools.js

@@ -5,13 +5,16 @@ async function executeFunctionCall(assistant, call, metadata = {}) {
   const name = call.name;
   const args = call.arguments ? JSON.parse(call.arguments) : {};
   
+  logger.info('[executeFunctionCall] Calling tool', { name, args, call_id: call.call_id });
+  
   let result, success = true;
   try {
     result = await assistant.executeTool(name, args);
+    logger.info('[executeFunctionCall] Tool completed', { name, call_id: call.call_id, duration_ms: Date.now() - startTime });
   } catch (error) {
     result = { error: error?.message || 'Tool execution failed' };
     success = false;
-    logger.error('[OpenAIResponsesProvider] Tool execution failed', { error });
+    logger.error('[executeFunctionCall] Tool execution failed', { name, call_id: call.call_id, error: error?.message });
   }
   
   const toolData = {

package/lib/providers/createProvider.js

@@ -1,5 +1,6 @@
 const { OpenAIAssistantsProvider } = require('./OpenAIAssistantsProvider');
 const { OpenAIResponsesProvider } = require('./OpenAIResponsesProvider');
+const { DefaultConversationManager } = require('../services/DefaultConversationManager');
 const { logger } = require('../utils/logger');
 
 const PROVIDER_VARIANTS = {
@@ -16,8 +17,17 @@ function createProvider(config = {}) {
     .toString()
     .toLowerCase();
 
+  // Create conversation manager if not provided
+  const conversationManager = config.conversationManager || new DefaultConversationManager({
+    memorySystem: config.memorySystem
+  });
+
   const ProviderClass = PROVIDER_VARIANTS[variant] || OpenAIAssistantsProvider;
-  return new ProviderClass({ ...config, variant });
+  return new ProviderClass({ 
+    ...config, 
+    variant, 
+    conversationManager 
+  });
 }
 
 module.exports = {

package/lib/routes/index.js

@@ -68,8 +68,8 @@ const templateRouteDefinitions = {
 };
 
 const threadRouteDefinitions = {
-  'PUT /review/:code': 'updateThreadReviewStatus',
   'PUT /review/all': 'updateAllThreadsReviewStatus',
+  'PUT /review/:code': 'updateThreadReviewStatus',
   'GET /review': 'getThreadsByReviewStatus'
 };
 

package/lib/services/ConversationManager.js

@@ -0,0 +1,43 @@
+const { logger } = require('../utils/logger');
+
+class ConversationManager {
+  constructor(options = {}) {
+    this.memorySystem = options.memorySystem || null;
+  }
+
+  async buildContext({ thread, assistant, config = {} }) {
+    throw new Error('buildContext must be implemented by subclass');
+  }
+
+  async processResponse(response, thread, config = {}) {
+    throw new Error('processResponse must be implemented by subclass');
+  }
+
+  setMemorySystem(memorySystem) {
+    this.memorySystem = memorySystem;
+  }
+
+  getMemorySystem() {
+    return this.memorySystem;
+  }
+
+  optimizeContextWindow(messages, maxTokens = 8000) {
+    if (!Array.isArray(messages) || messages.length === 0) return [];
+    const systemMessages = messages.filter(m => m.role === 'system');
+    const recentMessages = messages.filter(m => m.role !== 'system').slice(-20);
+    return [...systemMessages, ...recentMessages];
+  }
+
+  _convertToApiFormat(messages) {
+    return messages.map(msg => ({
+      role: msg.role || 'user',
+      content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)
+    }));
+  }
+
+  _logActivity(action, metadata = {}) {
+    logger.info(`[ConversationManager] ${action}`, metadata);
+  }
+}
+
+module.exports = { ConversationManager };

package/lib/services/DefaultConversationManager.js

@@ -0,0 +1,207 @@
+const { ConversationManager } = require('./ConversationManager');
+const { getLastNMessages } = require('../helpers/messageHelper');
+const { handlePendingFunctionCalls: handlePendingFunctionCallsUtil } = require('../providers/OpenAIResponsesProviderTools');
+const { getRecordByFilter } = require('./airtableService');
+const { Follow_Up_ID } = require('../config/airtableConfig');
+const { logger } = require('../utils/logger');
+
+class DefaultConversationManager extends ConversationManager {
+  constructor(options = {}) {
+    super(options);
+    this.maxHistoricalMessages = parseInt(process.env.MAX_HISTORICAL_MESSAGES || '50', 10);
+  }
+
+  async buildContext({ thread, assistant, config = {} }) {
+    this._logActivity('Building context', { threadCode: thread.code });
+
+    try {
+      const allMessages = await getLastNMessages(thread.code, this.maxHistoricalMessages);
+      const additionalMessages = config.additionalMessages || [];
+      
+      // New conversation - no history yet
+      if (!allMessages?.length) {
+        return additionalMessages;
+      }
+
+      const messageContext = allMessages.reverse().map(msg => ({
+        role: msg.origin === 'patient' ? 'user' : 'assistant',
+        content: msg.body || msg.content || ''
+      }));
+      
+      return [...additionalMessages, ...messageContext];
+    } catch (error) {
+      logger.error('[DefaultConversationManager] Context building failed', {
+        threadCode: thread.code,
+        error: error.message
+      });
+      throw error;
+    }
+  }
+
+  async processResponse(response, thread, config = {}) {
+    this._logActivity('Processing response', { threadCode: thread.code, responseId: response.id });
+
+    try {
+      if (this.memorySystem && response.output) {
+        await this.memorySystem.processResponse(response, thread);
+      }
+      this._logActivity('Response processed successfully', {
+        threadCode: thread.code,
+        responseId: response.id
+      });
+    } catch (error) {
+      logger.error('[DefaultConversationManager] Response processing failed', {
+        threadCode: thread.code,
+        error: error.message
+      });
+    }
+  }
+
+  async handlePendingFunctionCalls(assistant, conversationMessages, toolMetadata) {
+    if (!assistant || !conversationMessages?.length) return { outputs: [], toolsExecuted: [] };
+    
+    try {
+      return await handlePendingFunctionCallsUtil(assistant, conversationMessages, toolMetadata);
+    } catch (error) {
+      logger.error('[DefaultConversationManager] Function call handling failed', { error: error.message });
+      return { outputs: [], toolsExecuted: [] };
+    }
+  }
+
+  optimizeContextWindow(messages) {
+    if (!Array.isArray(messages) || !messages.length) return [];
+    
+    const cappedMessages = messages.length > this.maxHistoricalMessages
+      ? messages.slice(-this.maxHistoricalMessages)
+      : messages;
+
+    if (messages.length > this.maxHistoricalMessages) {
+      this._logActivity('Context capped', { originalCount: messages.length, cappedCount: this.maxHistoricalMessages });
+    }
+
+    return this._convertToApiFormat(cappedMessages);
+  }
+
+  _convertToApiFormat(items) {
+    return items.map(item => ({
+      role: item.role || 'user',
+      content: this._normalizeContent(item.content),
+      type: item.type || 'message',
+    }));
+  }
+
+  _normalizeContent(content) {
+    if (typeof content === 'string') return content;
+    if (Array.isArray(content)) return content;
+    if (content?.text) return content.text;
+    if (content?.type === 'text' && content.text) return content.text;
+    return content && typeof content === 'object' ? JSON.stringify(content) : content || '';
+  }
+
+  async _getClinicalContext(whatsappId) {
+    try {
+      const [clinicalRecords, symptomsRecords] = await Promise.all([
+        getRecordByFilter(Follow_Up_ID, 'estado_general', `{whatsapp_id}='${whatsappId}'`),
+        getRecordByFilter(Follow_Up_ID, 'all_triages_last_month', `{whatsapp_id}='${whatsappId}'`)
+      ]);
+
+      let clinicalContext = null;
+      if (clinicalRecords && clinicalRecords.length > 0 && clinicalRecords[0]['clinical-context-json']) {
+        clinicalContext = JSON.parse(clinicalRecords[0]['clinical-context-json']);
+      }
+
+      const sortedSymptoms = symptomsRecords
+        ?.filter(r => r.Date)
+        .sort((a, b) => new Date(b.Date) - new Date(a.Date))
+        .slice(0, 3) || [];
+
+      const symptoms = this._parseSymptoms(sortedSymptoms);
+      
+      return { ...clinicalContext, symptoms };
+    } catch (error) {
+      logger.error('[DefaultConversationManager] Error fetching clinical context', { error: error.message });
+      return null;
+    }
+  }
+
+  _parseSymptoms(records) {
+    if (!records || records.length === 0) return [];
+
+    return records.map(record => {
+      const symptomNames = record['symptom_name (from symptoms)'];
+      const grades = record['grade_num (from symptoms)'];
+      const recommendations = record['short_recommendations'];
+      const date = record['Date'];
+
+      if (!symptomNames || !grades) return null;
+
+      const nameArray = typeof symptomNames === 'string' 
+        ? symptomNames.split(',').map(s => s.trim())
+        : Array.isArray(symptomNames) ? symptomNames : [symptomNames];
+      
+      const gradeArray = typeof grades === 'string'
+        ? grades.split(',').map(g => parseInt(g.trim()))
+        : Array.isArray(grades) ? grades.map(g => parseInt(g)) : [parseInt(grades)];
+      
+      const recArray = recommendations && typeof recommendations === 'string'
+        ? recommendations.split('.,').map(r => r.trim())
+        : [];
+
+      const symptoms = nameArray
+        .map((name, idx) => ({
+          name,
+          grade: gradeArray[idx] || 0,
+          recommendation: recArray[idx] || ''
+        }))
+        .filter(s => s.grade > 0);
+
+      return {
+        date,
+        symptoms
+      };
+    }).filter(Boolean);
+  }
+
+  async getClinicalData(whatsappId) {
+    try {
+      const data = await this._getClinicalContext(whatsappId);
+      if (!data) return null;
+
+      // Format clinical context (demographics + clinical data)
+      const contextParts = [];
+      if (data.demografia) {
+        const d = data.demografia;
+        if (d.edad) contextParts.push(`Edad: ${d.edad}`);
+        if (d.sexo) contextParts.push(`Sexo: ${d.sexo}`);
+      }
+      if (data.datos_clinicos) {
+        const c = data.datos_clinicos;
+        if (c.diagnostico) contextParts.push(`Diagnóstico: ${c.diagnostico}`);
+        if (c.tratamiento_actual) contextParts.push(`Tratamiento actual: ${c.tratamiento_actual}`);
+        if (c.medicacion_actual) contextParts.push(`Medicación: ${c.medicacion_actual}`);
+        if (c.alergias_medicamentos) contextParts.push(`Alergias: ${c.alergias_medicamentos}`);
+        if (c.comorbilidades) contextParts.push(`Comorbilidades: ${c.comorbilidades}`);
+      }
+
+      // Format last symptoms
+      const symptomParts = [];
+      if (data.symptoms?.length > 0) {
+        data.symptoms.forEach(triage => {
+          const dateStr = new Date(triage.date).toLocaleDateString('es-PE');
+          const symptomsStr = triage.symptoms.map(s => `${s.name} (grado ${s.grade})`).join(', ');
+          if (symptomsStr) symptomParts.push(`${dateStr}: ${symptomsStr}`);
+        });
+      }
+
+      return {
+        clinicalContext: contextParts.join('. ') || '',
+        lastSymptoms: symptomParts.join('; ') || 'Sin síntomas reportados recientemente'
+      };
+    } catch (error) {
+      logger.error('[DefaultConversationManager] Error getting clinical data', { error: error.message });
+      return null;
+    }
+  }
+}
+
+module.exports = { DefaultConversationManager };

package/lib/services/airtableService.js

@@ -52,7 +52,7 @@ async function getRecordByFilter(baseID, tableName, filter, view = 'Grid view')
     });
     return records;
   } catch (error) {
-    logger.error(`Error fetching records by ${filter}:`, error);
+    logger.error(`Error fetching records from ${tableName} by ${filter}:`, error);
   }
 }
 

package/lib/services/assistantServiceCore.js

@@ -41,15 +41,6 @@ const createAssistantCore = async (code, assistant_id, messages = [], force = fa
   try {
     const assistant = getAssistantById(assistant_id, null);
     const initialThread = await assistant.create(code, curRow[0]);
-
-    const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
-    for (const message of messages) {
-      await provider.addMessage({
-        threadId: initialThread.id,
-        role: 'assistant',
-        content: message
-      });
-    }
     
     const thread = {
       code: code,
@@ -76,17 +67,9 @@ const addMsgAssistantCore = async (code, inMessages, role = 'system', reply = fa
   const thread = await getThread(code);
   if (!thread) return null;
 
-  const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
-  const threadId = thread.getConversationId();
-
   try {
     const messages = Array.isArray(inMessages) ? inMessages : [inMessages];
 
-    await provider.addMessage({ 
-      threadId, 
-      messages: messages.map(message => ({ role, content: message }))
-    });
-
     // Save system messages to database for frontend visibility
     if (!skipSystemMessage) {
       for (let i = 0; i < messages.length; i++) {
@@ -205,12 +188,6 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
     const urls = processResults.filter(r => r.url).map(r => ({ url: r.url }));
     const allMessagesToAdd = processResults.flatMap(r => r.messages || []);
     const allTempFiles = processResults.flatMap(r => r.tempFiles || []);
-    
-    if (allMessagesToAdd.length > 0) {
-      logger.info(`[replyAssistantCore] Adding ${allMessagesToAdd.length} messages to thread in batch`);
-      const threadId = finalThread.getConversationId();
-      await provider.addMessage({ threadId, messages: allMessagesToAdd });
-    }
 
     await Promise.all(processResults.map(r => updateMessageRecord(r.reply, finalThread)));
     await cleanupFiles(allTempFiles);