@peopl-health/nexus 2.5.2 → 2.5.4

package/lib/controllers/assistantController.js

@@ -3,8 +3,8 @@ const { Config_ID } = require('../config/airtableConfig');
 const { Thread } = require('../models/threadModel');
 
 const { getRecordByFilter } = require('../services/airtableService');
-const { createAssistant, addMsgAssistant, addInsAssistant } = require('../services/assistantService');
-const { getThreadInfo, switchAssistant } = require('../services/assistantService');
+const { createAssistant, addMsgAssistant, addInsAssistant, switchAssistant } = require('../services/assistantService');
+const { getThreadInfo } = require('../helpers/threadHelper');
 const { sendMessage } = require('../core/NexusMessaging');
 const { logger } = require('../utils/logger');
 
@@ -16,7 +16,7 @@ const activeAssistantController = async (req, res) => {
     await Thread.updateOne({ code }, { $set: { active: !!active } });
     return res.status(200).send({ message: 'Active assistant' });
   } catch (error) {
-    logger.error(error);
+    logger.error('[activeAssistantController] Error', { error: error.message, code });
     return res.status(500).send({ message: 'Failed to active assistant', error });
   }
 };
@@ -28,11 +28,11 @@ const addInsAssistantController = async (req, res) => {
     const variant = process.env.VARIANT || 'assistants';
     const role = variant === 'responses' ? 'developer' : 'user';
     
-    const ans = await addInsAssistant(code, instruction, role);
-    if (ans) await sendMessage({code, body: ans, fileType: 'text', origin: 'assistant'});
-    return res.status(200).send({ message: 'Add instruction to the assistant' });
+    const assistantReply = await addInsAssistant(code, instruction, role);
+    if (assistantReply) await sendMessage({code, body: assistantReply, fileType: 'text', origin: 'assistant'});
+    return res.status(200).send({ message: 'Instruction added to assistant', success: true });
   } catch (error) {
-    logger.error(error);
+    logger.error('[addInsAssistantController] Error', { error: error.message, code });
     res.status(500).send({ message: 'Failed to add instruction to assistant', error });
   }
 };
@@ -41,11 +41,11 @@ const addMsgAssistantController = async (req, res) => {
   const { code, messages, role = 'user', reply = false } = req.body;
 
   try {
-    const ans = await addMsgAssistant(code, messages, role, reply);
-    if (ans) await sendMessage({code, body: ans, fileType: 'text', origin: 'assistant'});
-    return res.status(200).send({ message: 'Add message to the assistant' });
+    const assistantReply = await addMsgAssistant(code, messages, role, reply);
+    if (assistantReply) await sendMessage({code, body: assistantReply, fileType: 'text', origin: 'assistant'});
+    return res.status(200).send({ message: 'Message added to assistant', success: true });
   } catch (error) {
-    logger.error(error);
+    logger.error('[addMsgAssistantController] Error', { error: error.message, code, role });
     res.status(500).send({ message: 'Failed to add message assistant', error });
   }
 };
@@ -59,18 +59,18 @@ const createAssistantController = async (req, res) => {
   messages = Array.isArray(messages) ? messages : [];
 
   try {
-    logger.info('[createAssistantController] codes', codes);
+    logger.info('[createAssistantController] codes', { codes });
     for (const code of codes) {
       await createAssistant(code, assistant_id, [...instrucciones, ...messages], force);
-      logger.info('[createAssistantController] messages', messages);
+      logger.info('[createAssistantController] messages', { messages });
       for (const message of messages) {
-        logger.info('[createAssistantController] message', message);
+        logger.info('[createAssistantController] message', { message });
         await sendMessage({code, body: message, fileType: 'text'});
       }
     }
     res.status(200).send({ message: 'Create the assistant' });
   } catch (error) {
-    logger.error(error);
+    logger.error('[createAssistantController] Error creating assistant', { error: error.message, stack: error.stack });
     res.status(500).send({ message: 'Failed to create assistant', error });
   }
 };
@@ -82,7 +82,7 @@ const getInfoAssistantController = async (req, res) => {
     let threadInfo = await getThreadInfo(code);
     return res.status(200).send({ message: 'Send assistant info' , threadInfo});
   } catch (error) {
-    logger.error(error);
+    logger.error('[getInfoAssistantController] Error', { error: error.message, code });
     res.status(500).send({ message: 'Failed to receive assistant info', error });
   }
 };
@@ -97,7 +97,7 @@ const listAssistantController = async (req, res) => {
     const assistants = await getRecordByFilter(Config_ID, tableName, `status="${airtableStatus}"`);
     return res.status(200).send({ message: 'List assistants' , assistants});
   } catch (error) {
-    logger.error(error);
+    logger.error('[listAssistantController] Error', { error: error.message });
     res.status(500).send({ message: 'Failed to list assistants', error });
   }
 };
@@ -109,7 +109,7 @@ const switchAssistantController = async (req, res) => {
     await switchAssistant(code, assistant_id);
     return res.status(200).send({ message: 'Switch assistant' });
   } catch (error) {
-    logger.error(error);
+    logger.error('[switchAssistantController] Error', { error: error.message, code, assistant_id });
     res.status(500).send({ message: 'Failed to switch assistant', error });
   }
 };
@@ -121,7 +121,7 @@ const stopAssistantController = async (req, res) => {
     await Thread.updateOne({ code }, { $set: { stopped: !!stop } });
     return res.status(200).send({ message: 'Stop assistant' });
   } catch (error) {
-    logger.error(error);
+    logger.error('[stopAssistantController] Error', { error: error.message, code, stop });
     return res.status(500).send({ message: 'Failed to stop assistant', error });
   }
 };

package/lib/core/NexusMessaging.js

@@ -354,18 +354,6 @@ class NexusMessaging {
 
     const chatId = messageData.from || messageData.From;
 
-    // Send initial typing indicator with delay
-    if (chatId && this.provider && typeof this.provider.sendTypingIndicator === 'function') {
-      const messageId = messageData.id || messageData.MessageSid || messageData.message_id;        
-      if (messageId) {
-        setTimeout(() => {
-          this.provider.sendTypingIndicator(messageId).catch(err => 
-            logger.debug('[processIncomingMessage] Typing indicator failed', { error: err.message })
-          );
-        }, 3000);
-      }
-    }
-
     if (chatId && hasPreprocessingHandler()) {
       const stop = await invokePreprocessingHandler({
         code: chatId,

package/lib/index.js

@@ -14,7 +14,7 @@ const {
   registerAssistant,
   overrideGetAssistantById,
   configureAssistants: setAssistantsConfig
-} = require('./services/assistantService');
+} = require('./services/assistantResolver');
 const { TwilioProvider } = require('./adapters/TwilioProvider');
 const { BaileysProvider } = require('./adapters/BaileysProvider');
 const { BaseAssistant } = require('./assistants/BaseAssistant');

package/lib/services/assistantResolver.js

@@ -0,0 +1,105 @@
+const llmConfig = require('../config/llmConfig');
+const { BaseAssistant } = require('../assistants/BaseAssistant');
+
+let assistantConfig = null;
+let assistantRegistry = {};
+let customGetAssistantById = null;
+
+const configureAssistants = (config) => {
+  if (!config) {
+    throw new Error('Assistant configuration is required');
+  }
+  assistantConfig = config;
+};
+
+const registerAssistant = (assistantId, definition) => {
+  if (!assistantId || typeof assistantId !== 'string') {
+    throw new Error('registerAssistant requires a string assistantId');
+  }
+
+  if (typeof definition === 'function') {
+    assistantRegistry[assistantId] = definition;
+    return definition;
+  }
+
+  if (definition && typeof definition === 'object') {
+    const {
+      extends: ParentClass = BaseAssistant,
+      create,
+      tools = [],
+      setup
+    } = definition;
+
+    class ConfiguredAssistant extends ParentClass {
+      constructor(options = {}) {
+        const provider = options.provider || llmConfig.getOpenAIProvider({ instantiate: false });
+        const sharedClient = options.client
+          || provider?.getClient?.()
+          || llmConfig.openaiClient
+          || null;
+
+        super({
+          ...options,
+          assistantId,
+          client: sharedClient,
+          provider,
+          tools: [...tools, ...(options.tools || [])]
+        });
+
+        if (typeof setup === 'function') {
+          setup.call(this, {
+            assistantId,
+            thread: this.thread,
+            options
+          });
+        }
+      }
+    }
+
+    if (typeof create === 'function') {
+      ConfiguredAssistant.prototype.create = async function(code, context) {
+        return await create.call(this, code, context);
+      };
+    }
+
+    assistantRegistry[assistantId] = ConfiguredAssistant;
+    return ConfiguredAssistant;
+  }
+
+  throw new Error('registerAssistant expects a class/function or configuration object');
+};
+
+const overrideGetAssistantById = (resolverFn) => {
+  if (typeof resolverFn === 'function') {
+    customGetAssistantById = resolverFn;
+  }
+};
+
+const getAssistantById = (assistant_id, thread) => {
+  if (customGetAssistantById) {
+    return customGetAssistantById(assistant_id, thread);
+  }
+
+  if (assistantRegistry[assistant_id]) {
+    const AssistantClass = assistantRegistry[assistant_id];
+    return new AssistantClass({ thread });
+  }
+
+  if (assistantConfig && assistantConfig[assistant_id]) {
+    const config = assistantConfig[assistant_id];
+    return new BaseAssistant({
+      ...config,
+      assistantId: assistant_id,
+      thread
+    });
+  }
+
+  throw new Error(`Assistant with ID "${assistant_id}" not found`);
+};
+
+module.exports = {
+  getAssistantById,
+  configureAssistants,
+  registerAssistant,
+  overrideGetAssistantById
+};

package/lib/services/assistantService.js

@@ -1,6 +1,5 @@
 const { withTracing } = require('../utils/tracingDecorator.js');
-const llmConfig = require('../config/llmConfig');
-const { BaseAssistant } = require('../assistants/BaseAssistant');
+const { runAssistantAndWait } = require('../helpers/assistantHelper');
 const {
   createAssistantCore,
   addMsgAssistantCore,
@@ -8,105 +7,15 @@ const {
   replyAssistantCore,
   switchAssistantCore
 } = require('./assistantServiceCore');
-
-let assistantConfig = null;
-let assistantRegistry = {};
-let customGetAssistantById = null;
-
-const configureAssistants = (config) => {
-  if (!config) {
-    throw new Error('Assistant configuration is required');
-  }
-  assistantConfig = config;
-};
-
-const registerAssistant = (assistantId, definition) => {
-  if (!assistantId || typeof assistantId !== 'string') {
-    throw new Error('registerAssistant requires a string assistantId');
-  }
-
-  if (typeof definition === 'function') {
-    assistantRegistry[assistantId] = definition;
-    return definition;
-  }
-
-  if (definition && typeof definition === 'object') {
-    const {
-      extends: ParentClass = BaseAssistant,
-      create,
-      tools = [],
-      setup
-    } = definition;
-
-    class ConfiguredAssistant extends ParentClass {
-      constructor(options = {}) {
-        const provider = options.provider || llmConfig.getOpenAIProvider({ instantiate: false });
-        const sharedClient = options.client
-          || provider?.getClient?.()
-          || llmConfig.openaiClient
-          || null;
-
-        super({
-          ...options,
-          assistantId,
-          client: sharedClient,
-          provider,
-          tools: [...tools, ...(options.tools || [])]
-        });
-
-        if (typeof setup === 'function') {
-          setup.call(this, {
-            assistantId,
-            thread: this.thread,
-            options
-          });
-        }
-      }
-    }
-
-    if (typeof create === 'function') {
-      ConfiguredAssistant.prototype.create = async function(code, context) {
-        return await create.call(this, code, context);
-      };
-    }
-
-    assistantRegistry[assistantId] = ConfiguredAssistant;
-    return ConfiguredAssistant;
-  }
-
-  throw new Error('registerAssistant expects a class/function or configuration object');
-};
-
-const overrideGetAssistantById = (resolverFn) => {
-  if (typeof resolverFn === 'function') {
-    customGetAssistantById = resolverFn;
-  }
-};
-
-const getAssistantById = (assistant_id, thread) => {
-  if (customGetAssistantById) {
-    return customGetAssistantById(assistant_id, thread);
-  }
-
-  if (assistantRegistry[assistant_id]) {
-    const AssistantClass = assistantRegistry[assistant_id];
-    return new AssistantClass({ thread });
-  }
-
-  if (assistantConfig && assistantConfig[assistant_id]) {
-    const config = assistantConfig[assistant_id];
-    return new BaseAssistant({
-      ...config,
-      assistantId: assistant_id,
-      thread
-    });
-  }
-
-  throw new Error(`Assistant with ID "${assistant_id}" not found`);
-};
+const {
+  getAssistantById,
+  configureAssistants,
+  registerAssistant,
+  overrideGetAssistantById
+} = require('./assistantResolver');
 
 const createAssistant = withTracing(
-  (code, assistant_id) => createAssistantCore(code, assistant_id, getAssistantById),
+  createAssistantCore,
   'create_assistant',
   (code, assistant_id) => ({
     'assistant.thread_code': code,
@@ -138,7 +47,7 @@ const addInsAssistant = withTracing(
 );
 
 const replyAssistant = withTracing(
-  (code, message_, thread_, runOptions) => replyAssistantCore(code, message_, thread_, runOptions, getAssistantById),
+  replyAssistantCore,
   'assistant_reply',
   (code, message_, thread_, runOptions) => ({
     'assistant.thread_code': code,
@@ -159,13 +68,14 @@ const switchAssistant = withTracing(
 );
 
 module.exports = {
-  getAssistantById,
   createAssistant,
   replyAssistant,
   addMsgAssistant,
   addInsAssistant,
   switchAssistant,
+  getAssistantById,
   configureAssistants,
   registerAssistant,
-  overrideGetAssistantById
+  overrideGetAssistantById,
+  runAssistantAndWait
 };

package/lib/services/assistantServiceCore.js

@@ -5,6 +5,7 @@ const { createProvider } = require('../providers/createProvider');
 const { Thread } = require('../models/threadModel.js');
 const { PredictionMetrics } = require('../models/predictionMetricsModel');
 const { insertMessage } = require('../models/messageModel');
+const { Historial_Clinico_ID } = require('../config/airtableConfig');
 
 const { getCurRow, runAssistantWithRetries } = require('../helpers/assistantHelper.js');
 const { getThread } = require('../helpers/threadHelper.js');
@@ -12,26 +13,27 @@ 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, getAssistantById) => {
+const createAssistantCore = async (code, assistant_id) => {
   const thread = await getThread(code);
   if (!thread) return null;
 
   const assistant = getAssistantById(assistant_id, thread);
-  const curRow = await getCurRow(code);
+  const curRow = await getCurRow(Historial_Clinico_ID, code);
   const context = { curRow };
 
   try {
     await assistant.create(code, context);
     return { success: true, assistant_id };
   } catch (error) {
-    logger.error('[createAssistantCore] Error:', error);
+    logger.error('[createAssistantCore] Error creating assistant', { error: error.message, assistant_id, code });
     return { success: false, error: error.message };
   }
 };
 
-const addMsgAssistantCore = async (code, message, role = 'user') => {
+const addMsgAssistantCore = async (code, message, role = 'user', reply = false) => {
   const thread = await getThread(code);
   if (!thread) return null;
 
@@ -41,10 +43,17 @@ const addMsgAssistantCore = async (code, message, role = 'user') => {
   try {
     await provider.addMessage({ threadId, messages: [{ role, content: message }] });
     await insertMessage({ code, message, role });
-    return { success: true };
+    
+    if (reply) {
+      const assistant = getAssistantById(thread.getAssistantId(), thread);
+      const runResult = await runAssistantWithRetries(thread, assistant, {});
+      return runResult?.output || null;
+    }
+    
+    return null;
   } catch (error) {
-    logger.error('[addMsgAssistantCore] Error:', error);
-    return { success: false, error: error.message };
+    logger.error('[addMsgAssistantCore] Error adding message', { error: error.message, code, role });
+    return null;
   }
 };
 
@@ -57,14 +66,16 @@ const addInstructionCore = async (code, instruction, role = 'user') => {
 
   try {
     await provider.addMessage({ threadId, messages: [{ role, content: instruction }] });
-    return { success: true };
+    const assistant = getAssistantById(thread.getAssistantId(), thread);
+    const runResult = await runAssistantWithRetries(thread, assistant, {});
+    return runResult?.output || null;
   } catch (error) {
-    logger.error('[addInstructionCore] Error:', error);
-    return { success: false, error: error.message };
+    logger.error('[addInstructionCore] Error adding instruction', { error: error.message, code, role });
+    return null;
   }
 };
 
-const replyAssistantCore = async (code, message_ = null, thread_ = null, runOptions = {}, getAssistantById) => {
+const replyAssistantCore = async (code, message_ = null, thread_ = null, runOptions = {}) => {
   const timings = {};
   const startTotal = Date.now();
   
@@ -175,12 +186,18 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
         retry_count: retries,
         completed: completed,
         timing_breakdown: timings
-      }).catch(err => logger.error('[replyAssistantCore] Failed to store metrics:', err));
+      }).catch(err => logger.error('[replyAssistantCore] Failed to store metrics', { error: err.message }));
     }
 
     return { output, tools_executed };
   } catch (error) {
-    logger.error('[replyAssistantCore] Error:', { error: error.message });
+    logger.error('[replyAssistantCore] Error in reply', { 
+      error: error.message,
+      stack: error.stack,
+      code: code ? `${code.substring(0, 3)}***${code.slice(-4)}` : 'unknown',
+      hasCustomThread: !!thread_,
+      hasMessage: !!message_
+    });
     throw error;
   }
 };
@@ -189,7 +206,8 @@ const switchAssistantCore = async (code, assistant_id) => {
   try {
     const thread = await Thread.findOne({ code });
     if (!thread) {
-      return null;
+      logger.warn('[switchAssistantCore] Thread not found', { code, assistant_id });
+      return { success: false, error: 'Thread not found' };
     }
 
     const updateFields = {
@@ -199,10 +217,16 @@ const switchAssistantCore = async (code, assistant_id) => {
     };
 
     await Thread.updateOne({ code }, { $set: updateFields });
+    logger.info('[switchAssistantCore] Assistant switched', { code, assistant_id });
     return { success: true, assistant_id };
   } catch (error) {
-    logger.info(error);
-    return null;
+    logger.error('[switchAssistantCore] Error switching assistant', { 
+      error: error.message, 
+      stack: error.stack,
+      code, 
+      assistant_id 
+    });
+    return { success: false, error: error.message };
   }
 };
 

package/package.json

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