@peopl-health/nexus 2.5.5 → 2.5.6

package/lib/providers/OpenAIResponsesProviderTools.js

@@ -2,144 +2,97 @@ const { logger } = require('../utils/logger');
 
 async function executeFunctionCall(assistant, call, metadata = {}) {
   const startTime = Date.now();
+  const name = call.name;
+  const args = call.arguments ? JSON.parse(call.arguments) : {};
+  
+  let result, success = true;
   try {
-    const name = call.name;
-    const args = call.arguments ? JSON.parse(call.arguments) : {};
-    const result = await assistant.executeTool(name, args);
-    const executionTime = Date.now() - startTime;
-    
-    const toolData = {
-      tool_name: name,
-      tool_arguments: args,
-      tool_output: result,
-      execution_time_ms: executionTime,
-      success: true,
-      call_id: call.call_id,
-      executed_at: new Date()
-    };
-    
-    return {
-      functionOutput: {
-        type: 'function_call_output',
-        call_id: call.call_id,
-        output: typeof result === 'string' ? result : JSON.stringify(result)
-      },
-      toolData
-    };
+    result = await assistant.executeTool(name, args);
   } catch (error) {
-    const executionTime = Date.now() - startTime;
-    
-    const toolData = {
-      tool_name: call.name,
-      tool_arguments: call.arguments ? JSON.parse(call.arguments) : {},
-      tool_output: { error: error?.message || 'Tool execution failed' },
-      execution_time_ms: executionTime,
-      success: false,
-      call_id: call.call_id,
-      executed_at: new Date()
-    };
-    
+    result = { error: error?.message || 'Tool execution failed' };
+    success = false;
     logger.error('[OpenAIResponsesProvider] Tool execution failed', error);
-    return {
-      functionOutput: {
-        type: 'function_call_output',
-        call_id: call.call_id,
-        output: JSON.stringify({ success: false, error: error?.message || 'Tool execution failed' })
-      },
-      toolData
-    };
   }
+  
+  const toolData = {
+    tool_name: name,
+    tool_arguments: args,
+    tool_output: result,
+    execution_time_ms: Date.now() - startTime,
+    success,
+    call_id: call.call_id,
+    executed_at: new Date()
+  };
+  
+  return {
+    functionOutput: {
+      type: 'function_call_output',
+      call_id: call.call_id,
+      output: success && typeof result === 'string' ? result : JSON.stringify(success ? result : { success: false, error: result.error })
+    },
+    toolData
+  };
 }
 
 /**
- * Handle pending function calls from conversation items
- * @param {Object} assistant - The assistant instance with executeTool method
- * @param {Array} conversationItems - Array of conversation items
- * @returns {Promise<Array>} Array of function call outputs
+ * Handle function calls from conversation items or run output
  */
-async function handlePendingFunctionCalls(assistant, conversationItems, metadata = {}) {
-  const pendingFunctionCalls = conversationItems.filter(item => item.type === 'function_call');
-  const functionOutputs = conversationItems.filter(item => item.type === 'function_call_output');
-  
-  const orphanedCalls = pendingFunctionCalls.filter(call => 
-    !functionOutputs.some(output => output.call_id === call.call_id)
-  );
-  
-  if (orphanedCalls.length === 0) {
+async function handleFunctionCalls(functionCalls, assistant, metadata = {}) {
+  if (!functionCalls || functionCalls.length === 0) {
     return { outputs: [], toolsExecuted: [] };
   }
 
-  logger.info(`[OpenAIResponsesProvider] Found ${orphanedCalls.length} pending function calls, handling them...`);
   const outputs = [];
   const toolsExecuted = [];
   
-  for (const call of orphanedCalls) {
+  for (const call of functionCalls) {
     const result = await executeFunctionCall(assistant, call, metadata);
     outputs.push(result.functionOutput);
     toolsExecuted.push(result.toolData);
   }
-  
+
   return { outputs, toolsExecuted };
 }
 
 /**
- * Handle function calls from a run output
- * @param {Object} assistant - The assistant instance with executeTool method
- * @param {Object} run - The run object with output array
- * @returns {Promise<Array>} Array of function call outputs
+ * Handle pending function calls from conversation items
  */
-async function handleRequiresAction(assistant, run, metadata = {}) {
-  const functionCalls = run.output?.filter(item => item.type === 'function_call') || [];
-  if (functionCalls.length === 0) {
-    return { outputs: [], toolsExecuted: [] };
-  }
-
-  const outputs = [];
-  const toolsExecuted = [];
+async function handlePendingFunctionCalls(assistant, conversationItems, metadata = {}) {
+  const outputCallIds = new Set(
+    conversationItems.filter(item => item.type === 'function_call_output').map(output => output.call_id)
+  );
   
-  for (const call of functionCalls) {
-    const result = await executeFunctionCall(assistant, call, metadata);
-    outputs.push(result.functionOutput);
-    toolsExecuted.push(result.toolData);
+  const orphanedCalls = conversationItems.filter(item => 
+    item.type === 'function_call' && !outputCallIds.has(item.call_id)
+  );
+  
+  if (orphanedCalls.length > 0) {
+    logger.info(`[OpenAIResponsesProvider] Found ${orphanedCalls.length} pending function calls, handling them...`);
   }
-
-  return { outputs, toolsExecuted };
+  
+  return handleFunctionCalls(orphanedCalls, assistant, metadata);
 }
 
 /**
  * Transform tools from Assistants API format to Responses API format
- * @param {string} variant - The API variant ('responses' or 'assistants')
- * @param {Array} tools - Array of tool definitions
- * @returns {Array|undefined} Transformed tools or undefined if empty
  */
 function transformToolsForResponsesAPI(variant, tools) {
-  if (variant !== 'responses' || !Array.isArray(tools) || tools.length === 0) {
-    return Array.isArray(tools) && tools.length > 0 ? tools : undefined;
-  }
+  if (variant !== 'responses' || !tools?.length) return tools?.length ? tools : undefined;
 
   return tools.map(tool => {
-    // If tool is in Assistants API format (type: 'function', function: {...})
     if (tool.type === 'function' && tool.function) {
-      const transformed = {
-        name: tool.function.name,
-        type: 'function',
-        description: tool.function.description,
-        parameters: tool.function.parameters
-      };
-      if (tool.function.strict !== undefined) {
-        transformed.strict = tool.function.strict;
-      }
+      const { name, description, parameters, strict } = tool.function;
+      const transformed = { name, type: 'function', description, parameters };
+      if (strict !== undefined) transformed.strict = strict;
       return transformed;
     }
-    // If already in Responses API format, return as-is
     return tool;
   });
 }
 
 module.exports = {
   executeFunctionCall,
+  handleFunctionCalls,
   handlePendingFunctionCalls,
-  handleRequiresAction,
   transformToolsForResponsesAPI
 };
-

package/lib/services/airtableService.js

@@ -7,7 +7,7 @@ async function addRecord(baseID, tableName, fields) {
     if (!airtable) throw new Error('Airtable not configured. Set AIRTABLE_API_KEY');
     const base = airtable.base(baseID);
     const record = await base(tableName).create(fields);
-    logger.info('Record added at', tableName);
+    logger.info('Record added at', { tableName });
     return record;
   } catch (error) {
     logger.error('Error adding record:', error);

package/lib/services/assistantServiceCore.js

@@ -11,29 +11,68 @@ const { getCurRow, runAssistantWithRetries } = require('../helpers/assistantHelp
 const { getThread } = require('../helpers/threadHelper.js');
 const { processThreadMessage } = require('../helpers/processHelper.js');
 const { getLastMessages, updateMessageRecord } = require('../helpers/messageHelper.js');
-const { withThreadRecovery } = require('../helpers/threadRecoveryHelper.js');
 const { combineImagesToPDF, cleanupFiles } = require('../helpers/filesHelper.js');
 const { getAssistantById } = require('./assistantResolver');
 const { logger } = require('../utils/logger');
 
-const createAssistantCore = async (code, assistant_id) => {
-  const thread = await getThread(code);
-  if (!thread) return null;
+const createAssistantCore = async (code, assistant_id, messages = [], force = false) => {
+  const findThread = await Thread.findOne({ code: code });
+  logger.info('[createAssistantCore] findThread', findThread);
+  
+  if (findThread && findThread.getConversationId() && !force) {
+    logger.info('[createAssistantCore] Thread already exists');
+    const updateFields = { active: true, stopped: false };
+    Thread.setAssistantId(updateFields, assistant_id);    
+    await Thread.updateOne({ code: code }, { $set: updateFields });
+    return { success: true, assistant_id, thread: findThread };
+  }
 
-  const assistant = getAssistantById(assistant_id, thread);
+  if (force && findThread?.getConversationId()) {
+    const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
+    await provider.deleteConversation(findThread.getConversationId());
+    logger.info('[createAssistantCore] Deleted old conversation, will create new one');
+  }
+  
   const curRow = await getCurRow(Historial_Clinico_ID, code);
-  const context = { curRow };
+  logger.info('[createAssistantCore] curRow', curRow[0]);
+  const nombre = curRow?.[0]?.['name'] || null;
+  const patientId = curRow?.[0]?.['record_id'] || null;
 
   try {
-    await assistant.create(code, context);
-    return { success: true, assistant_id };
+    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,
+      patient_id: patientId,
+      nombre: nombre,
+      active: true
+    };
+    Thread.setAssistantId(thread, assistant_id);
+    Thread.setConversationId(thread, initialThread.id);
+
+    const condition = { $or: [{ code: code }] };
+    const options = { new: true, upsert: true };
+    const updatedThread = await Thread.findOneAndUpdate(condition, { run_id: null, ...thread }, options);
+    logger.info('[createAssistantCore] Updated thread:', updatedThread);
+
+    return { success: true, assistant_id, thread: updatedThread };
   } catch (error) {
     logger.error('[createAssistantCore] Error creating assistant', { error: error.message, assistant_id, code });
-    return { success: false, error: error.message };
+    throw error;
   }
 };
 
-const addMsgAssistantCore = async (code, message, role = 'user', reply = false) => {
+const addMsgAssistantCore = async (code, inMessages, role = 'user', reply = false, skipSystemMessage = false) => {
   const thread = await getThread(code);
   if (!thread) return null;
 
@@ -41,16 +80,43 @@ const addMsgAssistantCore = async (code, message, role = 'user', reply = false)
   const threadId = thread.getConversationId();
 
   try {
-    await provider.addMessage({ threadId, messages: [{ role, content: message }] });
-    await insertMessage({ code, message, role });
-    
-    if (reply) {
-      const assistant = getAssistantById(thread.getAssistantId(), thread);
-      const runResult = await runAssistantWithRetries(thread, assistant, {});
-      return runResult?.output || null;
+    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++) {
+        const message = messages[i];
+        try {
+          const message_id = `system_${Date.now()}_${i}_${Math.random().toString(36).substring(7)}`;
+          await insertMessage({
+            nombre_whatsapp: 'System',
+            numero: code,
+            body: message,
+            message_id: message_id,
+            is_group: false,
+            is_media: false,
+            from_me: true,
+            processed: true,
+            origin: 'system',
+            assistant_id: thread.getAssistantId(),
+            raw: { role: role }
+          });
+        } catch (err) {
+          logger.error('[addMsgAssistantCore] Error saving system message:', err);
+        }
+      }
     }
-    
-    return null;
+
+    if (!reply) return null;
+
+    const assistant = getAssistantById(thread.getAssistantId(), thread);
+    const runResult = await runAssistantWithRetries(thread, assistant, {});
+    return runResult?.output || null;
   } catch (error) {
     logger.error('[addMsgAssistantCore] Error adding message', { error: error.message, code, role });
     return null;
@@ -61,13 +127,36 @@ const addInstructionCore = async (code, instruction, role = 'user') => {
   const thread = await getThread(code);
   if (!thread) return null;
 
-  const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
-  const threadId = thread.getConversationId();
-
   try {
-    await provider.addMessage({ threadId, messages: [{ role, content: instruction }] });
     const assistant = getAssistantById(thread.getAssistantId(), thread);
-    const runResult = await runAssistantWithRetries(thread, assistant, {});
+    const runResult = await runAssistantWithRetries(thread, assistant, {
+      additionalInstructions: instruction,
+      additionalMessages: [
+        { role: role, content: instruction }
+      ]
+    });
+
+    // Save instruction message to database for frontend visibility
+    try {
+      const message_id = `instruction_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+      await insertMessage({
+        nombre_whatsapp: 'Instruction',
+        numero: code,
+        body: instruction,
+        message_id: message_id,
+        is_group: false,
+        is_media: false,
+        from_me: true,
+        processed: true,
+        origin: 'instruction',
+        assistant_id: thread.getAssistantId(),
+        raw: { role: role }
+      });
+    } catch (err) {
+      logger.error('[addInstructionCore] Error saving instruction message:', err);
+    }
+
+    logger.info('[addInstructionCore] Run response', { output: runResult?.output });
     return runResult?.output || null;
   } catch (error) {
     logger.error('[addInstructionCore] Error adding instruction', { error: error.message, code, role });
@@ -80,14 +169,16 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
   const startTotal = Date.now();
   
   try {
+    const threadStart = Date.now();
     const thread = thread_ || await getThread(code);
-    timings.get_thread_ms = 0;
+    timings.get_thread_ms = Date.now() - threadStart;
     
     if (!thread) return null;
     const finalThread = thread;
 
+    const messagesStart = Date.now();
     const patientReply = await getLastMessages(code);
-    timings.get_messages_ms = 0;
+    timings.get_messages_ms = Date.now() - messagesStart;
     
     if (!patientReply) {
       logger.info('[replyAssistantCore] No relevant data found for this assistant.');
@@ -96,10 +187,11 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
 
     const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
     logger.info(`[replyAssistantCore] Processing ${patientReply.length} messages in parallel`);
+    const processStart = Date.now();
     const processResult = await processThreadMessage(code, patientReply, provider);
     
     const { results: processResults, timings: processTimings } = processResult;
-    timings.process_messages_ms = 0;
+    timings.process_messages_ms = Date.now() - processStart;
     
     logger.debug('[replyAssistantCore] Process timings breakdown', { processTimings });
 
@@ -120,14 +212,8 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
     
     if (allMessagesToAdd.length > 0) {
       logger.info(`[replyAssistantCore] Adding ${allMessagesToAdd.length} messages to thread in batch`);
-      await withThreadRecovery(
-        async (thread = finalThread) => {
-          const threadId = thread.getConversationId();
-          await provider.addMessage({ threadId, messages: allMessagesToAdd });
-        },
-        finalThread,
-        process.env.VARIANT || 'assistants'
-      );
+      const threadId = finalThread.getConversationId();
+      await provider.addMessage({ threadId, messages: allMessagesToAdd });
     }
 
     await Promise.all(processResults.map(r => updateMessageRecord(r.reply, finalThread)));
@@ -135,8 +221,9 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
 
     if (urls.length > 0) {
       logger.info(`[replyAssistantCore] Processing ${urls.length} URLs for PDF combination`);
+      const pdfStart = Date.now();
       const pdfResult = await combineImagesToPDF({ code });
-      timings.pdf_combination_ms = 0;
+      timings.pdf_combination_ms = Date.now() - pdfStart;
       const { pdfBuffer, processedFiles } = pdfResult;
       logger.info(`[replyAssistantCore] PDF combination complete: ${processedFiles?.length || 0} files processed`);
       
@@ -156,11 +243,12 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
     if (!patientMsg || finalThread.stopped) return null;
 
     const assistant = getAssistantById(finalThread.getAssistantId(), finalThread);
+    const runStart = Date.now();
     const runResult = await runAssistantWithRetries(finalThread, assistant, runOptions, patientReply);
-    timings.run_assistant_ms = 0;
+    timings.run_assistant_ms = Date.now() - runStart;
     timings.total_ms = Date.now() - startTotal;
     
-    const { run, output, completed, retries, predictionTimeMs, tools_executed } = runResult;
+    const { output, completed, retries, predictionTimeMs, tools_executed } = runResult;
 
     logger.info('[Assistant Reply Complete]', {
       code: code ? `${code.substring(0, 3)}***${code.slice(-4)}` : 'unknown',

package/lib/templates/templateStructure.js

@@ -216,7 +216,7 @@ class Template {
           }
           return a.localeCompare(b);
         })
-        .map(([key, value], index) => {
+        .map(([key, value]) => {
           if (typeof value === 'string') {
             return {
               name: `var_${key}`,

package/lib/utils/retryHelper.js

@@ -117,7 +117,8 @@ async function retryWithBackoff(operation, options = {}) {
   }
 
   try {
-    return await operation();
+    const result = await operation();
+    return { result, retries: retryCount };
   } catch (error) {
     const isRateLimit = error?.status === 429 || error?.code === 'rate_limit_exceeded';
     const isRetryable = isRetryableError(error);
@@ -148,7 +149,7 @@ async function retryWithBackoff(operation, options = {}) {
 
       await sleep(waitTime * 1000);
 
-      return retryWithBackoff(operation, { maxRetries, retryCount: retryCount + 1, providerName });
+      return await retryWithBackoff(operation, { maxRetries, retryCount: retryCount + 1, providerName });
     }
 
     throw error;

package/package.json

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