@peopl-health/nexus 2.0.17 → 2.1.0

package/examples/assistants/ExampleAssistant.js

@@ -86,26 +86,6 @@ class ExampleAssistant extends BaseAssistant {
     };
   }
 
-  /**
-   * Handle incoming messages with custom logic
-   * @param {string} userId - User identifier
-   * @param {string} message - User message
-   * @returns {Promise<string>} Response
-   */
-  async handleMessage(userId, message) {
-    // Add custom pre-processing logic here
-    console.log(`ExampleAssistant handling message from ${userId}: ${message}`);
-    
-    // Call parent method to handle LLM interaction
-    const response = await this.sendMessage(userId, message);
-    
-    // Add custom post-processing logic here
-    if (response) {
-      console.log(`ExampleAssistant responding to ${userId}: ${response}`);
-    }
-    
-    return response;
-  }
 }
 
 module.exports = { ExampleAssistant };

package/lib/assistants/BaseAssistant.js

@@ -159,94 +159,6 @@ class BaseAssistant {
     return await this.create(code, context);
   }
 
-  async sendMessage(userId, message, options = {}) {
-    this._ensureClient();
-
-    if (!this.thread || !this.thread.thread_id) {
-      throw new Error('Assistant thread not initialized. Call create() before sendMessage().');
-    }
-
-    const provider = this.provider || null;
-    if (!provider || typeof provider.addMessage !== 'function') {
-      throw new Error('Provider not configured. Ensure configureLLMProvider has been called.');
-    }
-
-    const assistantId = this.assistantId;
-    const threadId = this.thread.thread_id;
-    await provider.addMessage({ threadId, role: 'user', content: message });
-
-    const runConfig = { threadId, assistantId, ...options };
-
-    const toolSchemas = this.getToolSchemas();
-    if (toolSchemas.length > 0) {
-      runConfig.tools = toolSchemas;
-    }
-
-    const run = await provider.runConversation(runConfig);
-
-    return await this.waitForCompletion(threadId, run.id, options);
-  }
-
-  async waitForCompletion(threadId, runId, { interval = 2000, maxAttempts = 30 } = {}) {
-    this._ensureClient();
-    const provider = this.provider || null;
-    if (!provider || typeof provider.getRun !== 'function') {
-      throw new Error('Provider not configured. Cannot poll run status.');
-    }
-
-    let attempts = 0;
-    while (attempts < maxAttempts) {
-      const run = await provider.getRun({ threadId, runId });
-
-      if (!run) {
-        throw new Error('Unable to retrieve run status.');
-      }
-
-      if (run.status === 'completed') {
-        return run;
-      }
-
-      if (run.status === 'requires_action') {
-        await this.handleRequiresAction(run);
-      } else if (['failed', 'cancelled', 'expired', 'incomplete', 'errored'].includes(run.status)) {
-        throw new Error(`Assistant run ended with status '${run.status}'`);
-      }
-
-      await new Promise((resolve) => setTimeout(resolve, interval));
-      attempts += 1;
-    }
-
-    throw new Error('Assistant run timeout');
-  }
-
-  async getPreviousMessages(threadDoc) {
-    this._ensureClient();
-    const threadRef = threadDoc || this.thread;
-    if (!threadRef) return [];
-
-    const provider = this.provider || null;
-    if (!provider || typeof provider.listMessages !== 'function') {
-      throw new Error('OpenAI provider not configured. Cannot list messages.');
-    }
-
-    const response = await provider.listMessages({ threadId: threadRef.thread_id, order: 'asc' });
-    const messages = Array.isArray(response?.data) ? response.data : Array.isArray(response?.items) ? response.items : [];
-
-    return messages.map((msg) => {
-      const parts = Array.isArray(msg.content) ? msg.content : [];
-      const textContents = parts
-        .map((part) => {
-          if (part.type === 'text' && part.text?.value) return part.text.value;
-          if ((part.type === 'input_text' || part.type === 'output_text') && part.text) return part.text;
-          return null;
-        })
-        .filter(Boolean);
-
-      const content = textContents.length <= 1 ? textContents[0] || '' : textContents;
-      return { role: msg.role || 'user', content };
-    });
-  }
-
   async create(code, context = {}) {
     this._ensureClient();
     this.status = 'active';
@@ -285,44 +197,6 @@ class BaseAssistant {
     }];
   }
 
-  async handleRequiresAction(run) {
-    const toolCalls = run?.required_action?.submit_tool_outputs?.tool_calls || [];
-    if (toolCalls.length === 0) {
-      return [];
-    }
-
-    const outputs = [];
-
-    for (const call of toolCalls) {
-      try {
-        const name = call.function?.name;
-        const args = call.function?.arguments ? JSON.parse(call.function.arguments) : {};
-        const result = await this.executeTool(name, args);
-        outputs.push({ tool_call_id: call.id, output: typeof result === 'string' ? result : JSON.stringify(result) });
-      } catch (error) {
-        console.error('[BaseAssistant] Tool execution failed', error);
-        outputs.push({
-          tool_call_id: call.id,
-          output: JSON.stringify({ success: false, error: error?.message || 'Tool execution failed' })
-        });
-      }
-    }
-
-    const provider = this.provider || null;
-    if (!provider || typeof provider.submitToolOutputs !== 'function') {
-      console.warn('[BaseAssistant] Cannot submit tool outputs: provider not configured');
-      return outputs;
-    }
-
-    await provider.submitToolOutputs({
-      threadId: run.thread_id || this.thread?.thread_id,
-      runId: run.id,
-      toolOutputs: outputs
-    });
-
-    return outputs;
-  }
-
   async close() {
     this.status = 'closed';
     const assistantId = process.env.VARIANT === 'responses' ? this.thread?.prompt_id : this.thread?.assistant_id;

package/lib/controllers/assistantController.js

@@ -88,7 +88,8 @@ const listAssistantController = async (req, res) => {
     const nodeEnv = process.env.NODE_ENV;
     const airtableStatus = nodeEnv === 'production' ? 'prod' : 
       nodeEnv === 'development' ? 'dev' : nodeEnv;
-    const assistants = await getRecordByFilter(Config_ID, 'assistants', `status="${airtableStatus}"`);
+    const tableName = process.env.VARIANT === 'responses' ? 'prompts' : 'assistants';
+    const assistants = await getRecordByFilter(Config_ID, tableName, `status="${airtableStatus}"`);
     return res.status(200).send({ message: 'List assistants' , assistants});
   } catch (error) {
     console.log(error);

package/lib/helpers/assistantHelper.js

@@ -7,7 +7,6 @@ const { convertPdfToImages } = require('./filesHelper.js');
 const { analyzeImage } = require('../helpers/llmsHelper.js');
 
 const { getRecordByFilter } = require('../services/airtableService.js');
-const { createProvider } = require('../providers/createProvider');
 
 const fs = require('fs');
 const path = require('path');
@@ -15,51 +14,6 @@ const moment = require('moment-timezone');
 
 const mode = process.env.NODE_ENV || 'dev';
 
-
-async function checkRunStatus(assistant, thread_id, run_id, retryCount = 0, maxRetries = 10, actionHandled = false) {
-  try {
-    const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
-    const run = await provider.getRun({ threadId: thread_id, runId: run_id });
-    console.log(`Status: ${run.status} ${thread_id} ${run_id} (attempt ${retryCount + 1})`);
-
-    const failedStatuses = ['failed', 'expired', 'incomplete', 'errored'];
-    if (failedStatuses.includes(run.status)) {
-      console.log(`Run failed. ${run.status} `);
-      console.log('Error:');
-      console.log(run);
-      return false;
-    } else if (run.status === 'cancelled') {
-      console.log('cancelled');
-      return true;
-    } else if (run.status === 'requires_action') {
-      console.log('requires_action');
-      if (retryCount >= maxRetries) {
-        return false;
-      }
-      if (!actionHandled) {
-        await assistant.handleRequiresAction(run);
-        await new Promise(resolve => setTimeout(resolve, 5000));
-        return checkRunStatus(assistant, thread_id, run_id, retryCount + 1, maxRetries, true);
-      } else {
-        await new Promise(resolve => setTimeout(resolve, 1000));
-        return checkRunStatus(assistant, thread_id, run_id, retryCount + 1, maxRetries, actionHandled);
-      }
-    } else if (!['completed', 'succeeded'].includes(run.status)) {
-      if (retryCount >= maxRetries) {
-        return false;
-      }
-      await new Promise(resolve => setTimeout(resolve, 1000));
-      return checkRunStatus(assistant, thread_id, run_id, retryCount + 1, maxRetries, actionHandled);
-    } else {
-      console.log('Run completed.');
-      return true;
-    }
-  } catch (error) {
-    console.error('Error checking run status:', error);
-    return false;
-  }
-}
-
 async function checkIfFinished(text) {
   try {
     const provider = llmConfig.requireOpenAIProvider();
@@ -292,8 +246,7 @@ async function processIndividualMessage(code, reply, provider, thread) {
 
     console.log('[processIndividualMessage] messagesChat', messagesChat);
 
-    // ONLY add user messages to the thread
-    const threadId = process.env.VARIANT === 'responses' ? thread?.conversation_id : thread?.thread_id;
+    const threadId = thread.getConversationId();
     if (isNotAssistant) {
       await provider.addMessage({
         threadId,
@@ -303,10 +256,9 @@ async function processIndividualMessage(code, reply, provider, thread) {
       console.log(`[processIndividualMessage] User message added to thread ${threadId}`);
     }
 
-    const assistantId = process.env.VARIANT === 'responses' ? thread.prompt_id : thread.assistant_id;
     await Message.updateOne(
       { message_id: reply.message_id, timestamp: reply.timestamp },
-      { $set: { assistant_id: assistantId, thread_id: threadId } }
+      { $set: { assistant_id: thread.getAssistantId(), thread_id: threadId } }
     );
 
     return {isNotAssistant, url};
@@ -337,7 +289,6 @@ function getCurRow(baseID, code) {
 }
 
 module.exports = {
-  checkRunStatus,
   checkIfFinished,
   getLastMessages,
   getLastNMessages,

package/lib/index.d.ts

@@ -159,7 +159,6 @@ declare module '@peopl-health/nexus' {
     waitForCompletion(threadId: string, runId: string, opts?: { interval?: number; maxAttempts?: number }): Promise<any>;
     create(code: string, context?: any): Promise<any>;
     buildInitialMessages(context: { code: string; [key: string]: any }): Promise<Array<{ role: string; content: string }>>;
-    handleRequiresAction(run: any): Promise<any[]>;
     close(): Promise<string>;
     setThread(thread: any): void;
     setReplies(replies: any): void;

package/lib/models/threadModel.js

@@ -18,6 +18,36 @@ threadSchema.index({ code: 1, active: 1 });
 threadSchema.index({ thread_id: 1 });
 threadSchema.index({ conversation_id: 1 });
 
+threadSchema.methods.getConversationId = function() {
+  const variant = process.env.VARIANT || 'assistants';
+  return variant === 'assistants' ? this.thread_id : this.conversation_id;
+};
+
+threadSchema.methods.getAssistantId = function() {
+  const variant = process.env.VARIANT || 'assistants';
+  return variant === 'assistants' ? this.assistant_id : this.prompt_id;
+};
+
+threadSchema.statics.setAssistantId = function(threadObj, assistantId) {
+  const variant = process.env.VARIANT || 'assistants';
+  if (variant === 'assistants') {
+    threadObj.assistant_id = assistantId;
+  } else {
+    threadObj.prompt_id = assistantId;
+  }
+  return threadObj;
+};
+
+threadSchema.statics.setConversationId = function(threadObj, conversationId) {
+  const variant = process.env.VARIANT || 'assistants';
+  if (variant === 'assistants') {
+    threadObj.thread_id = conversationId;
+  } else {
+    threadObj.conversation_id = conversationId;
+  }
+  return threadObj;
+};
+
 const Thread = mongoose.model('Thread', threadSchema);
 
 module.exports = { Thread };

package/lib/providers/OpenAIAssistantsProvider.js

@@ -224,6 +224,84 @@ class OpenAIAssistantsProvider {
     });
   }
 
+  async handleRequiresAction(assistant, run, threadId) {
+    const toolCalls = run?.required_action?.submit_tool_outputs?.tool_calls || [];
+    if (toolCalls.length === 0) {
+      return [];
+    }
+
+    const outputs = [];
+
+    for (const call of toolCalls) {
+      try {
+        const name = call.function?.name;
+        const args = call.function?.arguments ? JSON.parse(call.function.arguments) : {};
+        const result = await assistant.executeTool(name, args);
+        outputs.push({ tool_call_id: call.id, output: typeof result === 'string' ? result : JSON.stringify(result) });
+      } catch (error) {
+        console.error('[OpenAIAssistantsProvider] Tool execution failed', error);
+        outputs.push({
+          tool_call_id: call.id,
+          output: JSON.stringify({ success: false, error: error?.message || 'Tool execution failed' })
+        });
+      }
+    }
+
+    await this.submitToolOutputs({
+      threadId: threadId || run.thread_id,
+      runId: run.id,
+      toolOutputs: outputs
+    });
+
+    return outputs;
+  }
+
+  async checkRunStatus(assistant, thread_id, run_id, retryCount = 0, maxRetries = 10, actionHandled = false) {
+    try {
+      const run = await this.getRun({ threadId: thread_id, runId: run_id });
+      console.log(`Status: ${run.status} ${thread_id} ${run_id} (attempt ${retryCount + 1})`);
+
+      const failedStatuses = ['failed', 'expired', 'incomplete', 'errored'];
+      if (failedStatuses.includes(run.status)) {
+        console.log(`Run failed. ${run.status} `);
+        console.log('Error:');
+        console.log(run);
+        return {run, completed: false};
+      } else if (run.status === 'cancelled') {
+        console.log('cancelled');
+        return {run, completed: true};
+      } else if (run.status === 'requires_action') {
+        console.log('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);
+      } else {
+        console.log('Run completed.');
+        return {run, completed: true};
+      }
+    } catch (error) {
+      console.error('Error checking run status:', error);
+      return {run: null, completed: false};
+    }
+  }
+
+  /**
+   * Internal helpers
+   */
   _normalizeContent(content) {
     if (content === undefined || content === null) {
       return [{ type: 'text', text: '' }];

package/lib/providers/OpenAIResponsesProvider.js

@@ -62,13 +62,14 @@ class OpenAIResponsesProvider {
   async deleteConversation(threadId) {
     const id = this._ensurethreadId(threadId);
     if (this.conversations && typeof this.conversations.del === 'function') {
-      return await this.conversations.del(id);
+      return await this.conversations.delete(id);
     }
     return await this._delete(`/conversations/${id}`);
   }
 
   async addMessage({ threadId, role = 'user', content, metadata }) {
     const id = this._ensurethreadId(threadId);
+    
     const payload = this._cleanObject({
       role,
       content: this._normalizeContent(role, content),
@@ -88,20 +89,47 @@ class OpenAIResponsesProvider {
     const id = this._ensurethreadId(threadId);
     const query = this._cleanObject({ order, limit });
 
-    if (this.conversations?.items && typeof this.conversations.items.list === 'function') {
-      return await this.conversations.items.list(id, query);
-    }
+    return await this.client.conversations.items.list(id, query);
+  }
+
+  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) {
+        console.log(`[OpenAIResponsesProvider] Deleting all ${items.length} items from conversation`);
+        for (const item of items) {
+          await this.conversations.items.delete(item.id, {conversation_id: id});
+        }
+        return;
+      }
 
-    return await this._get(`/conversations/${id}/items`, query);
+      const functionCalls = items.filter(item => item.type === 'function_call');
+      const functionOutputs = items.filter(item => item.type === 'function_call_output');
+      
+      for (const functionCall of functionCalls) {
+        const hasOutput = functionOutputs.some(output => output.call_id === functionCall.call_id);
+        
+        if (!hasOutput) {
+          console.log(`[OpenAIResponsesProvider] Deleting orphaned function_call: ${functionCall.id} (${functionCall.call_id})`);
+          await this.conversations.items.delete(functionCall.id, {conversation_id: id});
+        }
+      }
+    } catch (error) {
+      console.warn('[OpenAIResponsesProvider] Failed to cleanup conversation:', error?.message);
+    }
   }
 
   async runConversation({
     assistantId,
     threadId,
-    conversationId,
-    promptId,
     instructions,
     additionalMessages = [],
+    toolOutputs = [],
     additionalInstructions,
     metadata,
     topP,
@@ -110,28 +138,41 @@ class OpenAIResponsesProvider {
     truncationStrategy,
     tools = [],
   } = {}) {
-    const id = this._ensurethreadId(conversationId || threadId);
+    try {
+      const id = this._ensurethreadId(threadId);
+      const messages = this._responseInput(additionalMessages) || [];
+
+      const payload = this._cleanObject({
+        conversation: id,
+        prompt: { id: assistantId },
+        instructions: additionalInstructions || instructions,
+        input: [...messages, ...toolOutputs],
+        metadata,
+        top_p: topP,
+        temperature,
+        max_output_tokens: maxOutputTokens,
+        truncation_strategy: truncationStrategy,
+        tools: Array.isArray(tools) && tools.length ? tools : undefined,
+      });
 
-    const payload = this._cleanObject({
-      conversation: id,
-      prompt: { id: promptId },
-      instructions: additionalInstructions || instructions,
-      input: this._responseInput(additionalMessages),
-      metadata,
-      top_p: topP,
-      temperature,
-      max_output_tokens: maxOutputTokens,
-      truncation_strategy: truncationStrategy,
-      tools: Array.isArray(tools) && tools.length ? tools : undefined,
-    });
+      console.log('payload', payload);
+      const response = await this.client.responses.create(payload);
+      console.log('response', response);
 
-    const response = await this.client.responses.create(payload);
-    return {
-      ...response,
-      thread_id: id,
-      assistant_id: assistantId,
-      object: response.object || 'response',
-    };
+      if (response?.status !== 'completed') {
+        await this.cleanupOrphanedFunctionCalls(id, true);
+      }
+
+      return {
+        ...response,
+        thread_id: id,
+        assistant_id: assistantId,
+        object: response.object || 'response',
+      };
+    } catch (error) {
+      console.error('[OpenAIResponsesProvider] Error running conversation:', error);
+      throw error;
+    }
   }
 
   async getRun({ threadId, runId }) {
@@ -140,27 +181,7 @@ class OpenAIResponsesProvider {
   }
 
   async listRuns({ threadId, limit, order = 'desc', activeOnly = false } = {}) {
-    const id = this._ensurethreadId(threadId);
-    const query = this._cleanObject({ conversation: id, limit, order });
-
-    let responseList;
-    try {
-      responseList = await this._get('/responses', query);
-    } catch (error) {
-      console.warn('[OpenAIResponsesProvider] Failed to list responses:', error?.message || error);
-      responseList = { data: [] };
-    }
-
-    if (!activeOnly) {
-      return responseList;
-    }
-
-    const activeStatuses = ['queued', 'in_progress', 'processing', 'requires_action'];
-    const data = Array.isArray(responseList?.data)
-      ? responseList.data.filter((run) => activeStatuses.includes(run.status))
-      : [];
-
-    return { ...responseList, data };
+    return { data: [] };
   }
 
   async submitToolOutputs({ threadId, runId, toolOutputs }) {
@@ -237,6 +258,69 @@ class OpenAIResponsesProvider {
     });
   }
 
+  async handleRequiresAction(assistant, run, threadId) {
+    const functionCalls = run.output?.filter(item => item.type === 'function_call') || [];
+    if (functionCalls.length === 0) {
+      return [];
+    }
+
+    const outputs = [];
+
+    for (const call of functionCalls) {
+      try {
+        const name = call.name;
+        const args = call.arguments ? JSON.parse(call.arguments) : {};
+        const result = await assistant.executeTool(name, args);
+        outputs.push({
+          type: 'function_call_output',
+          call_id: call.call_id,
+          output: typeof result === 'string' ? result : JSON.stringify(result)
+        });
+      } catch (error) {
+        console.error('[OpenAIResponsesProvider] Tool execution failed', error);
+        outputs.push({
+          type: 'function_call_output',
+          call_id: call.call_id,
+          output: JSON.stringify({ success: false, error: error?.message || 'Tool execution failed' })
+        });
+      }
+    }
+
+    return outputs;
+  }
+
+  async checkRunStatus(assistant, thread_id, run_id, retryCount = 0, maxRetries = 10, actionHandled = false) {
+    try {
+      let run = await this.getRun({ threadId: thread_id, runId: run_id });
+      console.log(`Status: ${run.status} ${thread_id} ${run_id} (attempt ${retryCount + 1})`);
+
+      const needsFunctionCall = run.output?.some(item => item.type === 'function_call');
+      if (needsFunctionCall && !actionHandled) {
+        if (retryCount >= maxRetries) {
+          return {run, completed: false};
+        }
+
+        const outputs = await this.handleRequiresAction(assistant, run, thread_id);
+        console.log('[OpenAIResponsesProvider] Function call outputs:', outputs);
+        
+        if (outputs.length > 0) {
+          run = await this.runConversation({
+            threadId: thread_id,
+            assistantId: assistant.assistantId || assistant.promptId,
+            toolOutputs: outputs
+          });
+          
+          return this.checkRunStatus(assistant, thread_id, run.id, retryCount + 1, maxRetries, true);
+        }
+      }
+
+      return {run, completed: true};
+    } catch (error) {
+      console.error('Error checking run status:', error);
+      return {run: null, completed: false};
+    }
+  }
+
   /**
    * Internal helpers
    */

package/lib/services/assistantService.js

@@ -8,7 +8,7 @@ const { createProvider } = require('../providers/createProvider');
 const { Message, formatTimestamp } = require('../models/messageModel.js');
 const { Thread } = require('../models/threadModel.js');
 
-const { checkRunStatus, getCurRow } = require('../helpers/assistantHelper.js');
+const { getCurRow } = require('../helpers/assistantHelper.js');
 const { processIndividualMessage, getLastMessages } = require('../helpers/assistantHelper.js');
 const { combineImagesToPDF, cleanupFiles } = require('../helpers/filesHelper.js');
 const { delay } = require('../helpers/whatsappHelper.js');
@@ -30,7 +30,7 @@ const runAssistantAndWait = async ({
   assistant,
   runConfig = {}
 }) => {
-  if (!thread || !(thread.thread_id || thread.conversation_id)) {
+  if (!thread || !thread.getConversationId()) {
     throw new Error('runAssistantAndWait requires a thread with a valid thread_id or conversation_id');
   }
 
@@ -41,49 +41,35 @@ const runAssistantAndWait = async ({
   const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
   const { polling, ...conversationConfig } = runConfig || {};
 
-  const run = await provider.runConversation({
-    threadId: thread?.thread_id,
-    conversationId: thread?.conversation_id,
-    assistantId: thread?.assistant_id,
-    promptId: thread?.prompt_id,
+  let run = await provider.runConversation({
+    threadId: thread.getConversationId(),
+    assistantId: thread.getAssistantId(),
     ...conversationConfig,
   });
 
-  let output = null;
-  if (thread?.thread_id) {
-    const filter = thread.code ? { code: thread.code, active: true } : null;
-    if (filter) {
-      await Thread.updateOne(filter, { $set: { run_id: run.id } });
-    }
-
-    const maxRetries = polling?.maxRetries ?? 30;
-    let completed = false;
-
-    try {
-      console.log('RUN ID', run.id, thread.thread_id);
-      completed = await checkRunStatus(assistant, thread.thread_id, run.id, 0, maxRetries);
-    } finally {
-      if (filter) {
-        await Thread.updateOne(filter, { $set: { run_id: null } });
-      }
-    }
+  const filter = thread.code ? { code: thread.code, active: true } : null;
+  if (filter) {
+    await Thread.updateOne(filter, { $set: { run_id: run.id } });
+  }
 
-    let finalRun = run;
-    try {
-      finalRun = await provider.getRun({ threadId: run.thread_id, runId: run.id });
-    } catch (error) {
-      console.warn('Warning: unable to retrieve final run state:', error?.message || error);
-    }
+  const maxRetries = polling?.maxRetries ?? 30;
+  let completed = false;
 
-    if (!completed) {
-      return { run: finalRun, completed: false, output: '' };
+  try {
+    console.log('RUN ID', run.id, 'THREAD ID', thread.getConversationId(), 'ASSISTANT ID', thread.getAssistantId());
+    ({run, completed} = await provider.checkRunStatus(assistant, thread.getConversationId(), run.id, 0, maxRetries));
+  } finally {
+    if (filter) {
+      await Thread.updateOne(filter, { $set: { run_id: null } });
     }
+  }
 
-    output = await provider.getRunText({ threadId: run.thread_id, runId: run.id, fallback: '' });
-  } else {
-    output = run.output_text;
+  if (!completed) {
+    return { run: run, completed: false, output: '' };
   }
 
+  const output = await provider.getRunText({ threadId: thread.getConversationId(), runId: run.id, fallback: '' });
+
   return { completed: true, output };
 };
 
@@ -193,18 +179,11 @@ const getAssistantById = (assistant_id, thread) => {
 const createAssistant = async (code, assistant_id, messages=[], force=false) => {
   // If thread already exists, update it
   const findThread = await Thread.findOne({ code: code });
-  const variant = process.env.VARIANT || 'assistants';
   console.log('[createAssistant] findThread', findThread);
-  if ((findThread?.conversation_id && variant === 'responses') || (findThread?.thread_id && variant === 'assistants')) {
+  if (findThread && findThread.getConversationId()) {
     console.log('[createAssistant] Thread already exists');
     const updateFields = { active: true, stopped: false };
-    
-    if (variant === 'responses') {
-      updateFields.prompt_id = assistant_id;
-    } else {
-      updateFields.assistant_id = assistant_id;
-    }
-    
+    Thread.setAssistantId(updateFields, assistant_id);    
     await Thread.updateOne({ code: code }, { $set: updateFields });
     return findThread;
   }
@@ -218,7 +197,7 @@ const createAssistant = async (code, assistant_id, messages=[], force=false) =>
   const initialThread = await assistant.create(code, curRow[0]);
 
   // Add new messages to memory
-  const provider = createProvider({ variant: variant || 'assistants' });
+  const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
   for (const message of messages) {
     await provider.addMessage({
       threadId: initialThread.id,
@@ -227,32 +206,23 @@ const createAssistant = async (code, assistant_id, messages=[], force=false) =>
     });
   }
   
-  console.log('[createAssistant] initialThread', initialThread);
-  // Define new thread data
   const thread = {
     code: code,
-    assistant_id: assistant_id.startsWith('asst') ? assistant_id : null,
-    thread_id: initialThread.id.startsWith('thread') ? initialThread.id : null,
-    conversation_id: initialThread.id.startsWith('conv') ? initialThread.id : null,
-    prompt_id: assistant_id.startsWith('pmpt') ? assistant_id : null,
     patient_id: patientId,
     nombre: nombre,
     active: true
   };
-
-  const updateData = Object.fromEntries(
-    Object.entries(thread).filter(([_, v]) => v != null)
-  );
-  console.log('[createAssistant] updateData', updateData);
+  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, ...updateData}, options);
+  const updatedThread = await Thread.findOneAndUpdate(condition, {run_id: null, ...thread}, options);
   console.log('[createAssistant] Updated thread:', updatedThread);
 
   // Delete previous thread
   if (force) {
-    await provider.deleteConversation(findThread.conversation_id || findThread.thread_id);
+    await provider.deleteConversation(findThread.getConversationId());
   }
 
   return thread;
@@ -268,7 +238,7 @@ const addMsgAssistant = async (code, inMessages, reply = false) => {
     for (const message of inMessages) {
       console.log(message);
       await provider.addMessage({
-        threadId: thread.conversation_id || thread.thread_id,
+        threadId: thread.getConversationId(),
         role: 'assistant',
         content: message
       });
@@ -279,7 +249,7 @@ const addMsgAssistant = async (code, inMessages, reply = false) => {
     let output, completed;
     let retries = 0;
     const maxRetries = 10;
-    const assistant = getAssistantById(thread?.prompt_id || thread?.assistant_id, thread);
+    const assistant = getAssistantById(thread.getAssistantId(), thread);
     do {
       ({ output, completed } = await runAssistantAndWait({ thread, assistant }));
       console.log(`Attempt ${retries + 1}: completed=${completed}, output=${output || '(empty)'}`);
@@ -306,7 +276,7 @@ const addInsAssistant = async (code, instruction) => {
     let output, completed;
     let retries = 0;
     const maxRetries = 10;
-    const assistant = getAssistantById(thread?.prompt_id || thread?.assistant_id, thread);
+    const assistant = getAssistantById(thread.getAssistantId(), thread);
     do {
       ({ output, completed } = await runAssistantAndWait({
         thread,
@@ -352,7 +322,7 @@ const getThread = async (code, message = null) => {
     while (thread && thread.run_id) {
       console.log(`Wait for ${thread.run_id} to be executed`);
       const activeProvider = provider || llmConfig.requireOpenAIProvider();
-      const run = await activeProvider.getRun({ threadId: thread.conversation_id || thread.thread_id, runId: thread.run_id });
+      const run = await activeProvider.getRun({ threadId: thread.getConversationId(), runId: thread.run_id });
       if (run.status === 'cancelled' || run.status === 'expired' || run.status === 'completed') {
         await Thread.updateOne({ code: code }, { $set: { run_id: null } });
       }
@@ -390,16 +360,14 @@ const replyAssistant = async function (code, message_ = null, thread_ = null, ru
     }
 
     const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
-    if (!(thread?.conversation_id)) {
-      let activeRuns = await provider.listRuns({ threadId: thread.thread_id, activeOnly: true });
-      let activeRunsCount = activeRuns?.data?.length || 0;
-      console.log('ACTIVE RUNS:', activeRunsCount, activeRuns?.data?.map(run => ({ id: run.id, status: run.status })));
-      while (activeRunsCount > 0) {
-        console.log(`WAITING FOR ${activeRunsCount} ACTIVE RUNS TO COMPLETE - ${thread.thread_id}`);
-        activeRuns = await provider.listRuns({ threadId: thread.thread_id, activeOnly: true });
-        activeRunsCount = activeRuns?.data?.length || 0;
-        await delay(5000);
-      }
+    let activeRuns = await provider.listRuns({ threadId: thread.getConversationId(), activeOnly: true });
+    let activeRunsCount = activeRuns?.data?.length || 0;
+    console.log('ACTIVE RUNS:', activeRunsCount, activeRuns?.data?.map(run => ({ id: run.id, status: run.status })));
+    while (activeRunsCount > 0) {
+      console.log(`WAITING FOR ${activeRunsCount} ACTIVE RUNS TO COMPLETE - ${thread.getConversationId()}`);
+      activeRuns = await provider.listRuns({ threadId: thread.getConversationId(), activeOnly: true });
+      activeRunsCount = activeRuns?.data?.length || 0;
+      await delay(5000);
     }
 
     let patientMsg = false;
@@ -427,7 +395,7 @@ const replyAssistant = async function (code, message_ = null, thread_ = null, ru
 
     if (!patientMsg) return null;
 
-    const assistant = getAssistantById(process.env.VARIANT === 'responses' ? thread?.prompt_id : thread?.assistant_id, thread);
+    const assistant = getAssistantById(thread.getAssistantId(), thread);
     assistant.setReplies(patientReply);
 
     let run, output, completed;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peopl-health/nexus",
-  "version": "2.0.17",
+  "version": "2.1.0",
   "description": "Core messaging and assistant library for WhatsApp communication platforms",
   "keywords": [
     "whatsapp",
@@ -93,7 +93,7 @@
     "@anthropic-ai/sdk": "^0.32.0",
     "baileys": "^6.4.0",
     "express": "4.21.2",
-    "openai": "6.2.0",
+    "openai": "6.7.0",
     "twilio": "5.6.0"
   },
   "engines": {