@peopl-health/nexus 4.7.0-dev.450 → 5.0.0-dev.453

package/lib/clinical/helpers/assistantHelper.js

@@ -5,6 +5,7 @@ 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')) {
@@ -28,7 +29,11 @@ const runAssistantAndWait = async ({ thread, assistant, message = null, runConfi
   const { polling, tools: configTools, ...config } = runConfig;
   const tools = assistant.getToolSchemas?.() || configTools || [];
 
-  return provider.executeRun({ thread, message, assistant, tools, config, polling });
+  return withThreadRecovery(
+    (currentThread = thread) => provider.executeRun({ thread: currentThread, message, assistant, tools, config, polling }),
+    thread,
+    variant
+  );
 };
 
 const runAssistantWithRetries = async (thread, assistant, runConfig, patientReply = null) => {

package/lib/clinical/helpers/threadRecoveryHelper.js

@@ -0,0 +1,50 @@
+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
+};

package/lib/clinical/index.js

@@ -15,6 +15,7 @@ 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');
@@ -46,6 +47,7 @@ module.exports = {
   getCurRow,
   runAssistantAndWait,
   runAssistantWithRetries,
+  withThreadRecovery,
   analyzeImage,
   buildPrompt,
   getProviderVariant,

package/lib/clinical/providers/OpenRouterProvider.js

@@ -1,11 +1,6 @@
 const { OpenAI } = require('openai');
 
-const { retryWithBackoff } = require('../../utils/retryUtils');
-const { withTiming } = require('../../utils/tracingDecorator');
-const { safeParse } = require('../../utils/jsonUtils');
-
 const { OpenAIResponsesProvider } = require('./OpenAIResponsesProvider');
-const { handleFunctionCalls } = require('./OpenAIResponsesProviderTools');
 
 const OPENROUTER_BASE_URL = 'https://openrouter.ai/api/v1';
 const DEFAULT_MODEL_VENDOR = 'openai';
@@ -35,146 +30,9 @@ class OpenRouterProvider extends OpenAIResponsesProvider {
     this.transcriptionClient = null;
   }
 
-  async _invokeModel({
-    instructions, input, toolSchemas = [], toolChoice = 'auto', followUpToolChoice = 'auto',
-    modelConfig, assistant, phiProcessor = null, trace = null
-  }, options = {}) {
-    const executeTools = options.toolExecutor || handleFunctionCalls;
-    let totalRetries = 0;
-    const allToolsExecuted = [];
-    const allToolCalls = [];
-    const accumulatedUsage = { input_tokens: 0, output_tokens: 0, total_tokens: 0 };
-    const addUsage = (usage) => {
-      if (!usage) return;
-      accumulatedUsage.input_tokens += usage.prompt_tokens || 0;
-      accumulatedUsage.output_tokens += usage.completion_tokens || 0;
-      accumulatedUsage.total_tokens += usage.total_tokens || 0;
-    };
-
-    const messages = this._toChatMessages(instructions, input);
-    const apiCallConfig = { ...this._mapModelConfig(modelConfig) };
-    if (toolSchemas.length > 0) {
-      apiCallConfig.tools = toolSchemas;
-      apiCallConfig.tool_choice = toolChoice;
-    }
-
-    const makeAPICall = (msgs) => retryWithBackoff(
-      () => this.client.chat.completions.create({ messages: msgs, ...apiCallConfig }),
-      { providerName: this.constructor.name }
-    );
-
-    const { result: { result: response, retries }, durationMs } = await withTiming(() => makeAPICall(messages));
-    totalRetries += retries;
-    addUsage(response.usage);
-    let producingIteration = trace?.addIteration({ response, durationMs, apiCallConfig }) || null;
-    let finalResponse = response;
-    const currentMessages = [...messages];
-
-    if (assistant && toolSchemas.length > 0) {
-      apiCallConfig.tool_choice = followUpToolChoice;
-
-      for (let round = 1; round <= this.maxFunctionRounds; round++) {
-        const message = finalResponse.choices?.[0]?.message;
-        const toolCalls = message?.tool_calls || [];
-        if (!toolCalls.length) break;
-
-        const functionCalls = toolCalls.map(tc => ({
-          name: tc.function.name,
-          arguments: tc.function.arguments,
-          call_id: tc.id,
-        }));
-        allToolCalls.push(...toolCalls.map(tc => ({ name: tc.function.name, arguments: safeParse(tc.function.arguments), call_id: tc.id })));
-        const { outputs, toolsExecuted } = await executeTools(functionCalls, assistant, phiProcessor, producingIteration);
-
-        currentMessages.push(
-          message,
-          ...outputs.map(o => ({ role: 'tool', tool_call_id: o.call_id, content: this._toToolContent(o.output) }))
-        );
-        allToolsExecuted.push(...toolsExecuted);
-
-        const { result: { result: followUp, retries: followUpRetries }, durationMs: followUpDurationMs } = await withTiming(() => makeAPICall(currentMessages));
-        totalRetries += followUpRetries;
-        addUsage(followUp.usage);
-        producingIteration = trace?.addIteration({ response: followUp, durationMs: followUpDurationMs, apiCallConfig }) || null;
-        finalResponse = followUp;
-      }
-    }
-
-    return { response: this._normalizeResponse(finalResponse), toolCalls: allToolCalls, toolsExecuted: allToolsExecuted, retries: totalRetries, usage: accumulatedUsage };
-  }
-
-  _toChatMessages(instructions, input) {
-    const systemParts = [];
-    if (instructions) systemParts.push(instructions);
-
-    const outputsByCallId = new Map();
-    for (const item of input || []) {
-      if (item.type === 'function_call_output') outputsByCallId.set(item.call_id, item.output);
-    }
-
-    const messages = [];
-    for (const item of input || []) {
-      const type = item.type || 'message';
-      if (type === 'function_call') {
-        if (!outputsByCallId.has(item.call_id)) continue;
-        messages.push({
-          role: 'assistant',
-          content: null,
-          tool_calls: [{ id: item.call_id, type: 'function', function: { name: item.name, arguments: item.arguments || '{}' } }],
-        });
-        messages.push({ role: 'tool', tool_call_id: item.call_id, content: this._toToolContent(outputsByCallId.get(item.call_id)) });
-        continue;
-      }
-      if (type === 'function_call_output') continue;
-      const content = item.content;
-      if (item.role === 'developer' || item.role === 'system') {
-        if (content) systemParts.push(content);
-        continue;
-      }
-      messages.push({ role: item.role === 'assistant' ? 'assistant' : 'user', content });
-    }
-
-    const system = systemParts.join('\n\n');
-    return system ? [{ role: 'system', content: system }, ...messages] : messages;
-  }
-
-  _toToolContent(output) {
-    return typeof output === 'string' ? output : JSON.stringify(output ?? '');
-  }
-
-  _normalizeResponse(response) {
-    const choice = response.choices?.[0];
-    const outputText = (choice?.message?.content || '').trim();
-    const output = outputText
-      ? [{ type: 'message', role: 'assistant', content: [{ type: 'output_text', text: outputText }] }]
-      : [];
-    const usage = response.usage
-      ? {
-        input_tokens: response.usage.prompt_tokens || 0,
-        output_tokens: response.usage.completion_tokens || 0,
-        total_tokens: response.usage.total_tokens || 0,
-      }
-      : undefined;
-
-    return {
-      id: response.id,
-      object: 'response',
-      model: response.model,
-      status: choice?.finish_reason === 'content_filter' ? 'refused' : 'completed',
-      stop_reason: choice?.finish_reason,
-      output,
-      output_text: outputText,
-      usage,
-      raw: response,
-    };
-  }
-
   _mapModelConfig(modelConfig) {
-    const mapped = { ...(modelConfig || {}) };
-    if (mapped.max_tokens == null && mapped.max_output_tokens != null) mapped.max_tokens = mapped.max_output_tokens;
+    const mapped = { ...modelConfig };
     delete mapped.store;
-    delete mapped.text;
-    delete mapped.max_output_tokens;
     mapped.model = this._toOpenRouterModel(mapped.model || this.defaults.responseModel);
     return mapped;
   }

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 { getProviderVariant } = require('../clinical');
+const { withThreadRecovery, getProviderVariant, getOpenAIProvider } = require('../clinical');
 
 const Message = mongoose.models.Message;
 
@@ -470,45 +470,65 @@ const markMessagesAsReadController = async (req, res) => {
 const getOpenAIThreadMessagesController = async (req, res) => {
   try {
     const { code } = req.params;
-    const { order = 'desc' } = req.query;
-
+    const { limit = 50, order = 'desc', runId } = req.query;
+    const variant = getProviderVariant();
+    
     if (!code) {
       return res.status(400).json({
         success: false,
         error: 'Phone number is required'
       });
     }
-
-    const thread = await Thread.findOne({ code: code }).sort({ createdAt: -1 });
+    
+    let thread = await Thread.findOne({ code: code }).sort({ createdAt: -1 });
     if (!thread) {
       return res.status(404).json({
         success: false,
-        error: 'No active thread found for this phone number'
+        error: 'No active OpenAI thread found for this phone number'
       });
     }
-
-    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 }
+    
+    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
     );
-    messages.forEach(msg => { msg.body = msg.plainBody || msg.body; });
-
+    
     res.status(200).json({
       success: true,
-      variant: getProviderVariant(),
+      variant,
       phoneNumber: code,
       code,
       threadId: thread.conversation_id,
       assistantId: thread.assistant_id,
-      messages,
-      pagination: { limit: parsedLimit, order }
+      messages: messages.data || messages,
+      hasMore: messages.has_more || false,
+      threadRecreated,
+      pagination: { limit: parseInt(limit), order }
     });
   } catch (error) {
-    logger.error('Error fetching thread messages:', { error: error.message });
-    res.status(500).json({
-      success: false,
-      error: error.message || 'Failed to fetch thread messages'
+    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' 
     });
   }
 };

package/package.json

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