@peopl-health/nexus 2.5.5 → 2.5.6

package/lib/assistants/BaseAssistant.js

@@ -230,12 +230,18 @@ class BaseAssistant {
 
   async close() {
     this.status = 'closed';
-    const assistantId = process.env.VARIANT === 'responses' ? this.thread?.prompt_id : this.thread?.assistant_id;
+    const assistantId = this.thread?.getAssistantId(); 
     if (this.thread?.code && assistantId) {
-      const filter = process.env.VARIANT === 'responses' 
-        ? { code: this.thread.code, prompt_id: assistantId }
-        : { code: this.thread.code, assistant_id: assistantId };
-      await Thread.updateOne(filter, { $set: { active: false } });
+      await Thread.updateOne(
+        { 
+          code: this.thread.code,
+          $or: [
+            { assistant_id: assistantId },
+            { prompt_id: assistantId }
+          ]
+        },
+        { $set: { active: false } }
+      );
     }
 
     if (this.assistantId) {

package/lib/controllers/assistantController.js

@@ -25,10 +25,7 @@ const addInsAssistantController = async (req, res) => {
   const { code, instruction } = req.body;
   
   try {
-    const variant = process.env.VARIANT || 'assistants';
-    const role = variant === 'responses' ? 'developer' : 'user';
-    
-    const assistantReply = await addInsAssistant(code, instruction, role);
+    const assistantReply = await addInsAssistant(code, instruction, 'developer');
     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) {

package/lib/controllers/conversationController.js

@@ -678,9 +678,8 @@ const getOpenAIThreadMessagesController = async (req, res) => {
       limit: parseInt(limit) 
     };
     
-    if (variant === 'assistants' && runId) {
+    if (runId) {
       queryParams.runId = runId;
-      logger.info('Including runId:', runId);
     }
     
     let messages;

package/lib/helpers/assistantHelper.js

@@ -1,6 +1,3 @@
-const llmConfig = require('../config/llmConfig.js');
-
-const { Thread } = require('../models/threadModel.js');
 const { createProvider } = require('../providers/createProvider.js');
 const { withTracing } = require('../utils/tracingDecorator');
 const { withThreadRecovery } = require('./threadRecoveryHelper');
@@ -8,31 +5,6 @@ const { withThreadRecovery } = require('./threadRecoveryHelper');
 const { getRecordByFilter } = require('../services/airtableService.js');
 const { logger } = require('../utils/logger');
 
-const DEFAULT_MAX_RETRIES = parseInt(process.env.MAX_RETRIES || '30', 10);
-
-async function checkIfFinished(text) {
-  try {
-    const provider = llmConfig.requireOpenAIProvider();
-    const completion = await provider.createChatCompletion({
-      model: 'gpt-4o-mini',
-      messages: [
-        {
-          role: 'user', 
-          content: `Dado el siguiente dialogo, determina si el paciente desea finalizar la conversación.
-                    Considera que la conversación ha terminado si el paciente: 1)Agradece o se despide, usando expresiones como 'gracias', 'adiós', 'hasta luego', etc.
-                    2)Indica explícitamente que no tiene más síntomas o preguntas, o que no necesita más ayuda.
-                    3)Expresa que no desea continuar. O el asistente envia recomendaciones o se despide.
-                    Responde solo con 'Si' si la conversación ha terminado, o 'No' si aún continúa: Texto: "${text}`
-        }
-      ]
-    });
-    
-    return completion.choices[0].message.content;
-  } catch (error) {
-    logger.error('[checkIfFinished] Error checking run status:', error);
-  }
-}
-
 function getCurRow(baseID, code) {
   if (code.endsWith('@g.us')) {
     return getRecordByFilter(baseID, 'estado_general', `FIND("${code}", {Group ID})`);
@@ -55,116 +27,57 @@ const runAssistantAndWait = async ({
   }
 
   const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
-  const { polling, tools: configTools, ...conversationConfig } = runConfig || {};
-  const variant = provider.getVariant ? provider.getVariant() : (process.env.VARIANT || 'assistants');
+  const { polling, tools: configTools, ...config } = runConfig || {};
   const tools = assistant.getToolSchemas ? assistant.getToolSchemas() : (configTools || []);
 
   return await withThreadRecovery(
     async (currentThread = thread) => {
-      const toolMetadata = { numero: currentThread.code, assistant_id: currentThread.getAssistantId() };
-      const runConfigWithAssistant = variant === 'responses'
-        ? { ...conversationConfig, assistant, toolMetadata }
-        : conversationConfig;
-
-      let run = await provider.runConversation({
-        threadId: currentThread.getConversationId(),
-        assistantId: currentThread.getAssistantId(),
-        tools: tools.length > 0 ? tools : undefined,
-        ...runConfigWithAssistant,
+      return await provider.executeRun({
+        thread: currentThread,
+        assistant,
+        tools,
+        config,
+        polling
       });
-
-      const filter = currentThread.code ? { code: currentThread.code, active: true } : null;
-      if (filter) {
-        await Thread.updateOne(filter, { $set: { run_id: run.id } });
-      }
-
-      const maxRetries = polling?.maxRetries ?? DEFAULT_MAX_RETRIES;
-      let completed = false;
-      let tools_executed = run.tools_executed || [];
-
-      try {
-        logger.info('[runAssistantAndWait] Run started', { runId: run.id, threadId: currentThread.getConversationId(), assistantId: currentThread.getAssistantId() });
-        const result = await provider.checkRunStatus(assistant, currentThread.getConversationId(), run.id, 0, maxRetries, false, toolMetadata);
-        run = result.run;
-        completed = result.completed;
-        tools_executed = [...tools_executed, ...(result.tools_executed || [])];
-      } finally {
-        if (filter) {
-          await Thread.updateOne(filter, { $set: { run_id: null } });
-        }
-      }
-
-      if (!completed) {
-        return { run: run, completed: false, output: '', tools_executed };
-      }
-
-      const output = await provider.getRunText({ threadId: currentThread.getConversationId(), runId: run.id, fallback: '' });
-
-      return { completed: true, output, tools_executed };
     },
-    thread,
-    variant
+    thread
   );
 };
 
-const executeAssistantAttempt = async (thread, assistant, runConfig, attemptNumber) => {
-  const result = await runAssistantAndWait({
-    thread,
-    assistant,
-    runConfig
-  });
-  
-  logger.info(`[executeAssistantAttempt] Attempt ${attemptNumber}: completed=${result.completed}, output=${result.output || '(empty)'}`);
-  
-  return result;
-};
-
 const runAssistantWithRetries = async (thread, assistant, runConfig, patientReply = null) => {
   if (patientReply) {
     assistant.setReplies(patientReply);
   }
 
   const startTime = Date.now();
-  let run, output, completed, tools_executed;
-  let retries = 0;
-  const maxRetries = DEFAULT_MAX_RETRIES;
   
-  do {
-    retries++;
-    ({ run, output, completed, tools_executed } = await withTracing(
-      executeAssistantAttempt,
-      'assistant_attempt',
-      (thread, assistant, runConfig, attemptNumber) => ({
-        'attempt.number': attemptNumber,
-        'attempt.is_retry': attemptNumber > 1,
-        'attempt.max_attempts': maxRetries
-      })
-    )(thread, assistant, runConfig, retries));
-    
-    if (completed && output) break;
-    
-    if (retries < maxRetries) {
-      const delay = retries === 1 
-        ? 500
-        : Math.min(1000 * Math.pow(1.5, retries - 1), 5000);
-      logger.info(`[runAssistantWithRetries] Retry ${retries}, waiting ${delay}ms`);
-      await new Promise(resolve => setTimeout(resolve, delay));
-    }
-  } while (retries < maxRetries && (!completed || !output));
-
+  const result = await withTracing(
+    runAssistantAndWait,
+    'run_assistant_with_retries',
+    () => ({ 
+      'thread.id': thread.getConversationId(),
+      'assistant.id': thread.getAssistantId() 
+    })
+  )({ thread, assistant, runConfig });
+  
   const predictionTimeMs = Date.now() - startTime;
-
-  if (run?.last_error) logger.warn('[runAssistantWithRetries] Run error', { error: run.last_error });
-  logger.info('[runAssistantWithRetries] Run completed', { completed, outputLength: output?.length || 0, toolsExecuted: tools_executed?.length || 0 });
-  logger.info('[runAssistantWithRetries] TIMING', { predictionTimeMs, retries });
   
-  return { run, output, completed, retries, predictionTimeMs, tools_executed };
+  logger.info('[runAssistantWithRetries] Run completed', { 
+    completed: result.completed, 
+    outputLength: result.output?.length || 0, 
+    toolsExecuted: result.tools_executed?.length || 0,
+    predictionTimeMs 
+  });
+  
+  return { 
+    ...result, 
+    retries: result.retries || 0,
+    predictionTimeMs 
+  };
 };
 
 module.exports = {
-  checkIfFinished,
   getCurRow,
   runAssistantAndWait,
-  runAssistantWithRetries,
-  executeAssistantAttempt
+  runAssistantWithRetries
 };

package/lib/models/messageModel.js

@@ -138,6 +138,7 @@ async function insertMessage(values) {
       origin: values.origin,
       tools_executed: values.tools_executed || [],
       raw: values.raw || null,
+      assistant_id: values.assistant_id || null,
       statusInfo: values.statusInfo || (values.delivery_status ? {
         status: values.delivery_status,
         errorCode: values.delivery_error_code || null,

package/lib/providers/OpenAIAssistantsProvider.js

@@ -1,4 +1,5 @@
 const { OpenAI } = require('openai');
+const { Thread } = require('../models/threadModel');
 const { retryWithBackoff } = require('../utils/retryHelper');
 const { logger } = require('../utils/logger');
 
@@ -43,32 +44,13 @@ class OpenAIAssistantsProvider {
     return this.client;
   }
 
-  /**
-   * Retry helper wrapper that uses shared retry logic
-   * @private
-   */
-  async _retryWithBackoff(operation, options = {}) {
-    return retryWithBackoff(operation, {
-      ...options,
-      providerName: PROVIDER_NAME,
-    });
-  }
-
-  /**
-   * @deprecated Use _retryWithBackoff instead
-   * Kept for backward compatibility
-   */
-  async _retryWithRateLimit(operation, maxRetries = 3, retryCount = 0) {
-    return this._retryWithBackoff(operation, { maxRetries, retryCount });
-  }
-
   async createConversation({ metadata, messages = [], toolResources } = {}) {
-    const thread = await this._retryWithRateLimit(() => 
+    const { result: thread } = await retryWithBackoff(() => 
       this.client.beta.threads.create({
         metadata,
         tool_resources: toolResources,
       })
-    );
+    , { providerName: PROVIDER_NAME });
 
     if (Array.isArray(messages) && messages.length > 0) {
       for (const message of messages) {
@@ -79,10 +61,6 @@ class OpenAIAssistantsProvider {
     return thread;
   }
 
-  async deleteConversation(threadId) {
-    await this.client.beta.threads.del(this._ensureId(threadId));
-  }
-
   async addMessage({ threadId, messages, role = 'user', content, metadata }) {
     const id = this._ensureId(threadId);
     const messagesToAdd = messages || [{ role, content, metadata }];
@@ -99,9 +77,9 @@ class OpenAIAssistantsProvider {
         payload.metadata = msg.metadata;
       }
       
-      const result = await this._retryWithRateLimit(() => 
+      const { result } = await retryWithBackoff(() => 
         this.client.beta.threads.messages.create(id, payload)
-      );
+      , { providerName: PROVIDER_NAME });
       results.push(result);
     }
     return messages ? results : results[0];
@@ -141,6 +119,83 @@ class OpenAIAssistantsProvider {
     return fallback;
   }
 
+  /**
+   * Normalize thread object to unified format
+   */
+  _normalizeThread(thread) {
+    return {
+      conversationId: thread.thread_id || thread.getConversationId?.(),
+      assistantId: thread.assistant_id || thread.getAssistantId?.()
+    };
+  }
+
+
+  /**
+   * Main entry point for running assistant
+   */
+  async executeRun({ thread, assistant, tools = [], config = {}, polling = {} }) {
+    const { conversationId, assistantId } = this._normalizeThread(thread);
+
+    logger.info('[OpenAIAssistantsProvider] Starting run', {
+      conversationId,
+      assistantId
+    });
+
+    const filter = thread.code ? { code: thread.code, active: true } : null;
+    
+    const run = await this.runConversation({
+      threadId: conversationId,
+      assistantId,
+      tools,
+      ...config
+    });
+
+    if (filter) {
+      await Thread.updateOne(filter, { $set: { run_id: run.id } });
+    }
+
+    let result;
+    try {
+      logger.info('[OpenAIAssistantsProvider] Polling run status', { runId: run.id });
+      result = await this.checkRunStatus(assistant, conversationId, run.id);
+    } finally {
+      if (filter) {
+        await Thread.updateOne(filter, { $set: { run_id: null } });
+      }
+    }
+
+    if (!result.completed) {
+      logger.warn('[OpenAIAssistantsProvider] Run did not complete', { runId: run.id });
+      return {
+        run: result.run,
+        completed: false,
+        output: '',
+        tools_executed: result.tools_executed || [],
+        retries: run.retries || 0
+      };
+    }
+
+    const output = await this.getRunText({ 
+      threadId: conversationId, 
+      runId: result.run.id, 
+      fallback: '' 
+    });
+
+    logger.info('[OpenAIAssistantsProvider] Run complete', {
+      runId: result.run.id,
+      completed: true,
+      toolsExecuted: result.tools_executed?.length || 0
+    });
+
+    return {
+      run: result.run,
+      completed: true,
+      output,
+      tools_executed: result.tools_executed || [],
+      retries: run.retries || 0
+    };
+  }
+
   async runConversation({
     threadId,
     assistantId,
@@ -167,27 +222,23 @@ class OpenAIAssistantsProvider {
       tools,
     };
 
-    if (Array.isArray(payload.additional_messages) && payload.additional_messages.length === 0) {
-      delete payload.additional_messages;
-    }
-
-    if (Array.isArray(payload.tools) && payload.tools.length === 0) {
-      delete payload.tools;
-    }
-
-    if (payload.metadata && Object.keys(payload.metadata).length === 0) {
-      delete payload.metadata;
-    }
-
-    Object.keys(payload).forEach((key) => {
-      if (payload[key] === undefined || payload[key] === null) {
+    // Clean up empty/null values
+    Object.keys(payload).forEach(key => {
+      if (payload[key] === null || payload[key] === undefined || 
+          (Array.isArray(payload[key]) && payload[key].length === 0) ||
+          (payload[key] && typeof payload[key] === 'object' && Object.keys(payload[key]).length === 0)) {
         delete payload[key];
       }
     });
 
-    return this._retryWithRateLimit(() => 
+    const { result, retries } = await retryWithBackoff(() => 
       this.client.beta.threads.runs.create(this._ensureId(threadId), payload)
-    );
+    , { providerName: PROVIDER_NAME });
+    
+    return {
+      ...result,
+      retries: retries
+    };
   }
 
   async getRun({ threadId, runId }) {
@@ -195,23 +246,6 @@ class OpenAIAssistantsProvider {
     return run;
   }
 
-  async listRuns({ threadId, limit, order = 'desc', activeOnly = false } = {}) {
-    const runs = await this.client.beta.threads.runs.list(this._ensureId(threadId), {
-      limit,
-      order,
-    });
-
-    if (activeOnly) {
-      const activeStatuses = ['in_progress', 'queued', 'requires_action'];
-      return {
-        ...runs,
-        data: runs.data.filter((run) => activeStatuses.includes(run.status)),
-      };
-    }
-
-    return runs;
-  }
-
   async submitToolOutputs({ threadId, runId, toolOutputs }) {
     return this.client.beta.threads.runs.submitToolOutputs(
       this._ensureId(runId),
@@ -222,33 +256,6 @@ class OpenAIAssistantsProvider {
     );
   }
 
-  async cancelRun({ threadId, runId }) {
-    return this.client.beta.threads.runs.cancel(
-      this._ensureId(runId),
-      { thread_id: this._ensureId(threadId) }
-    );
-  }
-
-  async createChatCompletion({ model, messages, temperature, maxTokens, topP, metadata, responseFormat } = {}) {
-    return this.client.chat.completions.create({
-      model: model || this.defaults.chatModel,
-      messages,
-      temperature,
-      max_tokens: maxTokens,
-      top_p: topP,
-      metadata,
-      response_format: responseFormat,
-    });
-  }
-
-  async uploadFile({ file, purpose }) {
-    if (!file) {
-      throw new Error('uploadFile requires a readable file stream or object');
-    }
-
-    return this.client.files.create({ file, purpose: purpose || 'assistants' });
-  }
-
   async transcribeAudio({ file, model, language, responseFormat, temperature, prompt } = {}) {
     return this.client.audio.transcriptions.create({
       model: model || this.defaults.transcriptionModel,
@@ -292,46 +299,40 @@ class OpenAIAssistantsProvider {
     return outputs;
   }
 
-  async checkRunStatus(assistant, thread_id, run_id, retryCount = 0, maxRetries = DEFAULT_MAX_RETRIES, actionHandled = false) {
+  async checkRunStatus(assistant, threadId, runId, attempt = 0, maxRetries = DEFAULT_MAX_RETRIES) {
+    if (attempt >= maxRetries) return { run: null, completed: false };
+    
     try {
-      const run = await this.getRun({ threadId: thread_id, runId: run_id });
-      logger.info(`Status: ${run.status} ${thread_id} ${run_id} (attempt ${retryCount + 1})`);
-
-      const failedStatuses = ['failed', 'expired', 'incomplete', 'errored'];
-      if (failedStatuses.includes(run.status)) {
-        logger.info(`Run failed. ${run.status} `);
-        logger.info('Error:');
-        logger.info(run);
-        return {run, completed: false};
-      } else if (run.status === 'cancelled') {
-        logger.info('cancelled');
-        return {run, completed: true};
-      } else if (run.status === 'requires_action') {
+      const run = await this.getRun({ threadId, runId });
+      logger.info(`Status: ${run.status} ${threadId} ${runId} (attempt ${attempt + 1})`);
+      
+      if (['failed', 'expired', 'incomplete', 'errored'].includes(run.status)) {
+        logger.info(`Run failed: ${run.status}`);
+        return { run, completed: false };
+      }
+      
+      if (['completed', 'succeeded'].includes(run.status)) {
+        logger.info('Run completed.');
+        return { run, completed: true };
+      }
+      
+      if (run.status === 'cancelled') {
+        logger.info('Run cancelled');
+        return { run, completed: true };
+      }
+      
+      if (run.status === 'requires_action') {
         logger.info('requires_action');
-        if (retryCount >= maxRetries) {
-          return {run, completed: false};
-        }
-        if (!actionHandled) {
-          await this.handleRequiresAction(assistant, run, thread_id);
-          await new Promise(resolve => setTimeout(resolve, 5000));
-          return this.checkRunStatus(assistant, thread_id, run_id, retryCount + 1, maxRetries, true);
-        } else {
-          await new Promise(resolve => setTimeout(resolve, 1000));
-          return this.checkRunStatus(assistant, thread_id, run_id, retryCount + 1, maxRetries, actionHandled);
-        }
-      } else if (!['completed', 'succeeded'].includes(run.status)) {
-        if (retryCount >= maxRetries) {
-          return {run, completed: false};
-        }
-        await new Promise(resolve => setTimeout(resolve, 1000));
-        return this.checkRunStatus(assistant, thread_id, run_id, retryCount + 1, maxRetries, actionHandled);
+        await this.handleRequiresAction(assistant, run, threadId);
+        await new Promise(resolve => setTimeout(resolve, 5000));
       } else {
-        logger.info('Run completed.');
-        return {run, completed: true};
+        await new Promise(resolve => setTimeout(resolve, 1000));
       }
+      
+      return this.checkRunStatus(assistant, threadId, runId, attempt + 1, maxRetries);
     } catch (error) {
       logger.error('Error checking run status:', error);
-      return {run: null, completed: false};
+      return { run: null, completed: false };
     }
   }