@peopl-health/nexus 4.7.0-dev.449 → 4.7.0-dev.450

package/lib/clinical/helpers/assistantHelper.js

@@ -5,7 +5,6 @@ const { withTracing } = require('../../utils/tracingDecorator');
 const { logger } = require('../../utils/logger');
 
 const { getRecordByFilter } = require('../../services/airtableService.js');
-const { withThreadRecovery } = require('./threadRecoveryHelper');
 
 function getCurRow(baseID, code) {
   if (code.endsWith('@g.us')) {
@@ -29,11 +28,7 @@ const runAssistantAndWait = async ({ thread, assistant, message = null, runConfi
   const { polling, tools: configTools, ...config } = runConfig;
   const tools = assistant.getToolSchemas?.() || configTools || [];
 
-  return withThreadRecovery(
-    (currentThread = thread) => provider.executeRun({ thread: currentThread, message, assistant, tools, config, polling }),
-    thread,
-    variant
-  );
+  return provider.executeRun({ thread, message, assistant, tools, config, polling });
 };
 
 const runAssistantWithRetries = async (thread, assistant, runConfig, patientReply = null) => {

package/lib/clinical/index.js

@@ -15,7 +15,6 @@ const { BaseAssistant } = require('./assistants/BaseAssistant');
 const { AssistantProcessor } = require('./AssistantProcessor');
 
 const { getCurRow, runAssistantAndWait, runAssistantWithRetries } = require('./helpers/assistantHelper');
-const { withThreadRecovery } = require('./helpers/threadRecoveryHelper');
 const { analyzeImage, buildPrompt } = require('./helpers/llmsHelper');
 
 const { getProviderVariant, getAnthropicClient, setOpenAIProvider, getOpenAIProvider, requireOpenAIProvider, configureOpenAIProvider } = require('./config/llmConfig');
@@ -47,7 +46,6 @@ module.exports = {
   getCurRow,
   runAssistantAndWait,
   runAssistantWithRetries,
-  withThreadRecovery,
   analyzeImage,
   buildPrompt,
   getProviderVariant,

package/lib/controllers/conversationController.js

@@ -14,7 +14,7 @@ const { fetchConversationData, processConversations, startConversation } = requi
 const { getMessages, countMessages, aggregateMessages } = require('../services/messageService');
 
 const { sendMessage } = require('../core/NexusMessaging');
-const { withThreadRecovery, getProviderVariant, getOpenAIProvider } = require('../clinical');
+const { getProviderVariant } = require('../clinical');
 
 const Message = mongoose.models.Message;
 
@@ -470,65 +470,45 @@ const markMessagesAsReadController = async (req, res) => {
 const getOpenAIThreadMessagesController = async (req, res) => {
   try {
     const { code } = req.params;
-    const { limit = 50, order = 'desc', runId } = req.query;
-    const variant = getProviderVariant();
-    
+    const { order = 'desc' } = req.query;
+
     if (!code) {
       return res.status(400).json({
         success: false,
         error: 'Phone number is required'
       });
     }
-    
-    let thread = await Thread.findOne({ code: code }).sort({ createdAt: -1 });
+
+    const thread = await Thread.findOne({ code: code }).sort({ createdAt: -1 });
     if (!thread) {
       return res.status(404).json({
         success: false,
-        error: 'No active OpenAI thread found for this phone number'
+        error: 'No active thread found for this phone number'
       });
     }
-    
-    const provider = getOpenAIProvider({ instantiate: true, variant });
-    if (!provider) throw new Error('OpenAI provider not initialized');
-    
-    const queryParams = {
-      threadId: thread.conversation_id,
-      order,
-      limit: parseInt(limit),
-      ...(runId && { runId })
-    };
-    let threadRecreated = false;
-    
-    const messages = await withThreadRecovery(
-      async (currentThread = thread) => {
-        if (currentThread !== thread) {
-          thread = currentThread;
-          queryParams.threadId = currentThread.getConversationId();
-          threadRecreated = true;
-        }
-        return await provider.listMessages(queryParams);
-      },
-      thread,
-      variant
+
+    const parsedLimit = Math.min(Math.max(parseInt(req.query.limit) || 50, 1), 100);
+    const messages = await getMessages(
+      { numero: code, group_id: null },
+      { sort: { createdAt: order === 'asc' ? 1 : -1 }, limit: parsedLimit }
     );
-    
+    messages.forEach(msg => { msg.body = msg.plainBody || msg.body; });
+
     res.status(200).json({
       success: true,
-      variant,
+      variant: getProviderVariant(),
       phoneNumber: code,
       code,
       threadId: thread.conversation_id,
       assistantId: thread.assistant_id,
-      messages: messages.data || messages,
-      hasMore: messages.has_more || false,
-      threadRecreated,
-      pagination: { limit: parseInt(limit), order }
+      messages,
+      pagination: { limit: parsedLimit, order }
     });
   } catch (error) {
-    logger.error('Error fetching OpenAI thread messages:', { error: error.message });
-    res.status(500).json({ 
-      success: false, 
-      error: error.message || 'Failed to fetch OpenAI thread messages' 
+    logger.error('Error fetching thread messages:', { error: error.message });
+    res.status(500).json({
+      success: false,
+      error: error.message || 'Failed to fetch thread messages'
     });
   }
 };

package/package.json

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

package/lib/clinical/helpers/threadRecoveryHelper.js

@@ -1,50 +0,0 @@
-const { createLLMProvider } = require('../providers/createLLMProvider');
-const { logger } = require('../../utils/logger');
-
-const { Thread } = require('../../models/threadModel');
-
-const THREAD_ERROR_CODES = ['thread_not_found', 'invalid_thread_id'];
-const THREAD_ERROR_MESSAGES = ['No thread found', 'thread does not exist', 'Invalid thread'];
-
-const isThreadNotFoundError = (error) => 
-  error?.status === 404 || 
-  THREAD_ERROR_CODES.includes(error?.code) ||
-  THREAD_ERROR_MESSAGES.some(msg => error?.message?.includes(msg));
-
-const recreateThread = async (thread, variant) => {
-  const provider = createLLMProvider({ variant });
-  const newConversation = await provider.createConversation({ 
-    metadata: { code: thread.code }
-  });
-  
-  await Thread.updateOne(
-    { code: thread.code },
-    { $set: { conversation_id: newConversation.id } }
-  );
-  
-  logger.info('[threadRecovery] Recreated', { 
-    oldId: thread.conversation_id, 
-    newId: newConversation.id,
-    code: thread.code 
-  });
-  return Thread.findOne({ code: thread.code });
-};
-
-const withThreadRecovery = async (operation, thread, variant) => {
-  try {
-    return await operation();
-  } catch (error) {
-    if (isThreadNotFoundError(error) && thread) {
-      logger.warn('[threadRecovery] Thread not found, recreating', { code: thread.code });
-      const recoveredThread = await recreateThread(thread, variant);
-      return operation(recoveredThread);
-    }
-    throw error;
-  }
-};
-
-module.exports = {
-  isThreadNotFoundError,
-  recreateThread,
-  withThreadRecovery
-};