@peopl-health/nexus 5.0.0-dev.453 → 5.0.0-dev.458

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

@@ -3,6 +3,7 @@ const { OpenAIResponsesProvider } = require('./providers/OpenAIResponsesProvider
 const { handleFunctionCalls } = require('./providers/OpenAIResponsesProviderTools');
 const { OpenRouterProvider } = require('./providers/OpenRouterProvider');
 const { AnthropicProvider } = require('./providers/AnthropicProvider');
+const { GatewayProvider } = require('./providers/GatewayProvider');
 
 const { composePrompt, resolveTools, clearCache } = require('./services/promptComposerService');
 const { createAssistant, preProcessMessages, switchAssistant } = require('./services/assistantService');
@@ -15,7 +16,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');
@@ -30,6 +30,7 @@ module.exports = {
   handleFunctionCalls,
   OpenRouterProvider,
   AnthropicProvider,
+  GatewayProvider,
   composePrompt,
   resolveTools,
   clearCache,
@@ -47,7 +48,6 @@ module.exports = {
   getCurRow,
   runAssistantAndWait,
   runAssistantWithRetries,
-  withThreadRecovery,
   analyzeImage,
   buildPrompt,
   getProviderVariant,

package/lib/clinical/providers/BaseLLMProvider.js

@@ -51,7 +51,7 @@ class BaseLLMProvider {
 
     const toolSchemas = this._resolveToolSchemas({ assistant, toolIds, filtered, toolDescriptions });
     const devContent = this._buildInstructions({ resolvedPrompt, toolSchemas, prePromptResult, additionalInstructions });
-    const input = this._buildInput({ context, prePromptResult, additionalInstructions, promptVariables });
+    const input = this._buildInput({ context, prePromptResult, additionalInstructions, promptVariables, modelConfig });
 
     trace?.setPrompt({ resolved: devContent, resolvedPresetId, resolvedPresetVersion });
 
@@ -137,13 +137,13 @@ class BaseLLMProvider {
     return { role: 'user', content: CONVERSATION_CONTINUATION };
   }
 
-  _buildInput({ context, prePromptResult, additionalInstructions, promptVariables }) {
+  _buildInput({ context, prePromptResult, additionalInstructions, promptVariables, modelConfig = null }) {
     let messages = this._convertItemsToApiFormat(context || []);
     if (Array.isArray(prePromptResult?.additionalMessages) && prePromptResult.additionalMessages.length > 0) {
       messages = [...messages, ...this._convertItemsToApiFormat(prePromptResult.additionalMessages)];
     }
     if (additionalInstructions) {
-      messages = [...messages, this._operatorInstructionTurn(additionalInstructions)];
+      messages = [...messages, this._operatorInstructionTurn(additionalInstructions, modelConfig)];
     }
     return this._sanitizeInput([...this._buildMemoryMessage(promptVariables), ...messages]);
   }
@@ -160,12 +160,8 @@ class BaseLLMProvider {
     throw new Error(`${this.constructor.name} must implement _invokeModel()`);
   }
 
-  async createConversation() {
-    throw new Error(`createConversation is not supported by ${this.constructor.name}`);
-  }
-
-  async listMessages() {
-    throw new Error(`listMessages is not supported by ${this.constructor.name}`);
+  _mapModelConfig(modelConfig) {
+    return modelConfig;
   }
 
   async transcribeAudio() {
@@ -420,13 +416,6 @@ class BaseLLMProvider {
     if (segments.length > 1) logger.debug(`[${this.constructor.name}] Concatenated transcript detected, using last segment`, { segmentCount: segments.length });
     return segments[segments.length - 1].trim();
   }
-
-  _ensureId(value) {
-    if (!value) throw new Error('Identifier value is required');
-    if (typeof value === 'string') return value;
-    if (value?.id) return value.id;
-    throw new Error('Unable to resolve identifier value');
-  }
 }
 
 module.exports = {

package/lib/clinical/providers/GatewayProvider.js

@@ -0,0 +1,84 @@
+const { composePrompt } = require('../services/promptComposerService');
+
+const { BaseLLMProvider } = require('./BaseLLMProvider');
+
+const VENDOR_VARIANT = {
+  openai: 'responses',
+  anthropic: 'anthropic',
+  openrouter: 'openrouter',
+};
+
+class GatewayProvider extends BaseLLMProvider {
+  constructor(options = {}) {
+    super(options);
+    this.variant = 'gateway';
+    this.supportsPromptRegistry = true;
+    this._subs = {};
+  }
+
+  _defaultSub() {
+    return this._sub('openai');
+  }
+
+  getClient() {
+    return this._defaultSub().getClient();
+  }
+
+  transcribeAudio(options) {
+    return this._defaultSub().transcribeAudio(options);
+  }
+
+  _operatorInstructionTurn(additionalInstructions, modelConfig = null) {
+    const { vendor } = this._route(modelConfig?.model);
+    return this._sub(vendor)._operatorInstructionTurn(additionalInstructions);
+  }
+
+  _route(model) {
+    if (!model) return { vendor: 'openai', model: undefined };
+    const slash = model.indexOf('/');
+    if (slash === -1) return { vendor: 'openai', model };
+    const vendor = model.slice(0, slash);
+    if (vendor === 'openai' || vendor === 'anthropic' || vendor === 'openrouter') {
+      return { vendor, model: model.slice(slash + 1) };
+    }
+    return { vendor: 'openrouter', model };
+  }
+
+  _sub(vendor) {
+    if (this._subs[vendor]) return this._subs[vendor];
+    const variant = VENDOR_VARIANT[vendor];
+    const { createLLMProvider } = require('./createLLMProvider');
+    try {
+      this._subs[vendor] = createLLMProvider({
+        variant,
+        conversationManager: this.conversationManager,
+        sessionManager: this.sessionManager,
+      });
+    } catch (err) {
+      throw new Error(`Gateway routed a model to '${vendor}' but its provider could not be created: ${err.message}`);
+    }
+    return this._subs[vendor];
+  }
+
+  async _invokeModel(request, options = {}) {
+    const { vendor, model } = this._route(request?.modelConfig?.model);
+    const modelConfig = { ...request.modelConfig, model };
+    return this._sub(vendor)._invokeModel({ ...request, modelConfig }, options);
+  }
+
+  async runStructured(params = {}) {
+    const { promptId = null, presetId = null, variables = null } = params;
+    let model = null;
+    if (promptId || presetId) {
+      const composed = await composePrompt({ promptId, presetId, variables });
+      model = composed.modelConfig?.model || null;
+    }
+    const { vendor, model: routedModel } = this._route(model);
+    if (vendor !== 'openai') {
+      throw new Error(`runStructured is only supported for OpenAI models; routed model '${model}' resolved to '${vendor}'`);
+    }
+    return this._sub('openai').runStructured({ ...params, model: routedModel });
+  }
+}
+
+module.exports = { GatewayProvider };

package/lib/clinical/providers/OpenAIResponsesProvider.js

@@ -10,9 +10,6 @@ const { logger } = require('../../utils/logger');
 const { BaseLLMProvider } = require('./BaseLLMProvider');
 const { handleFunctionCalls } = require('./OpenAIResponsesProviderTools');
 
-const CONVERSATION_PREFIX = 'conv_';
-const MAX_ITEMS_ON_CREATE = 20;
-const MAX_ITEMS_PER_BATCH = 20;
 const DEFAULT_MAX_FUNCTION_ROUNDS = 5;
 
 class OpenAIResponsesProvider extends BaseLLMProvider {
@@ -46,76 +43,12 @@ class OpenAIResponsesProvider extends BaseLLMProvider {
     this.supportsPromptRegistry = true;
 
     this.responses = this.client.responses;
-    this.conversations = this.client.conversations;
   }
 
   _operatorInstructionTurn(additionalInstructions) {
     return { role: 'developer', content: `[Instrucción del operador para tu próxima respuesta al paciente]: ${additionalInstructions}` };
   }
 
-  async createConversation({ metadata, messages = [], toolResources } = {}) {
-    const maxHistoricalMessages = this.conversationManager.maxHistoricalMessages;
-    const capped = messages.length > maxHistoricalMessages;
-    const messagesToProcess = capped ? messages.slice(-maxHistoricalMessages) : messages;
-    if (capped) {
-      logger.warn(`[createConversation] Capped ${messages.length} → ${maxHistoricalMessages} messages`);
-    }
-
-    const allItems = this._convertItemsToApiFormat(messagesToProcess);
-    const initialItems = allItems.slice(0, MAX_ITEMS_ON_CREATE);
-    const remainingItems = allItems.slice(MAX_ITEMS_ON_CREATE);
-
-    if (remainingItems.length) {
-      logger.info(`[createConversation] Batching: ${initialItems.length} initial + ${remainingItems.length} remaining`);
-    }
-
-    const conversation = await this._createConversationWithItems(metadata, initialItems, toolResources);
-
-    if (remainingItems.length) {
-      try {
-        await this._addItemsInBatches(conversation.id, remainingItems);
-      } catch (error) {
-        logger.error('[createConversation] Failed to add remaining messages', { error: error.message });
-      }
-    }
-
-    return conversation;
-  }
-
-  async _createConversationWithItems(metadata, items, toolResources) {
-    const payload = { 
-      metadata,
-      items: items.length ? items : undefined,
-      tool_resources: toolResources
-    };
-    const { result } = await retryWithBackoff(
-      () => this.conversations.create(payload),
-      { providerName: this.constructor.name }
-    );
-    return result;
-  }
-
-  async _addItemsInBatches(threadId, items, batchSize = MAX_ITEMS_PER_BATCH) {
-    if (!items?.length) return;
-
-    const id = this._ensurethreadId(threadId);
-    for (let i = 0; i < items.length; i += batchSize) {
-      const batch = this._convertItemsToApiFormat(items.slice(i, i + batchSize));
-      await retryWithBackoff(
-        () => this.conversations.items.create(id, { items: batch }),
-        { providerName: this.constructor.name }
-      );
-    }
-    logger.info(`[_addItemsInBatches] Added ${items.length} messages in ${Math.ceil(items.length / batchSize)} batches`);
-  }
-
-  async listMessages({ threadId, order = 'desc', limit } = {}) {
-    return this.client.conversations.items.list(
-      this._ensurethreadId(threadId), 
-      { order, limit }
-    );
-  }
-
   async _invokeModel({
     instructions, input, toolSchemas = [], toolChoice = 'auto', followUpToolChoice = 'auto',
     modelConfig, metadata = {}, assistant, phiProcessor = null,
@@ -200,7 +133,7 @@ class OpenAIResponsesProvider extends BaseLLMProvider {
     return { response: finalResponse, toolCalls: allToolCalls, toolsExecuted: allToolsExecuted, retries: totalRetries, usage: accumulatedUsage };
   }
 
-  async runStructured({ promptId = null, presetId = null, instructions = null, variables = null, input = [], text = null, metadata = null } = {}) {
+  async runStructured({ promptId = null, presetId = null, instructions = null, variables = null, input = [], text = null, metadata = null, model = null } = {}) {
     let modelConfig = null;
     let resolvedInstructions = instructions;
     if (promptId || presetId) {
@@ -213,6 +146,7 @@ class OpenAIResponsesProvider extends BaseLLMProvider {
       ...this._mapModelConfig(modelConfig || {}),
       instructions: resolvedInstructions || '',
     };
+    if (model) apiConfig.model = model;
     if (!apiConfig.model) apiConfig.model = this.defaults.responseModel;
     if (text) apiConfig.text = text;
     if (metadata) {
@@ -227,25 +161,12 @@ class OpenAIResponsesProvider extends BaseLLMProvider {
     return result;
   }
 
-  _mapModelConfig(modelConfig) {
-    return modelConfig;
-  }
-
   async transcribeAudio({ file, model, language, responseFormat, temperature, prompt } = {}) {
     return this.client.audio.transcriptions.create({
       model: model || this.defaults.transcriptionModel,
       file, language, response_format: responseFormat, temperature, prompt,
     });
   }
-
-  _ensurethreadId(value) {
-    const id = this._ensureId(value);
-    if (!id.startsWith(CONVERSATION_PREFIX)) {
-      throw new Error(`Expected conversation id to start with '${CONVERSATION_PREFIX}'`);
-    }
-    return id;
-  }
-
 }
 
 module.exports = {

package/lib/clinical/providers/OpenRouterProvider.js

@@ -1,6 +1,11 @@
 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';
@@ -30,9 +35,146 @@ 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 };
+    const mapped = { ...(modelConfig || {}) };
+    if (mapped.max_tokens == null && mapped.max_output_tokens != null) mapped.max_tokens = mapped.max_output_tokens;
     delete mapped.store;
+    delete mapped.text;
+    delete mapped.max_output_tokens;
     mapped.model = this._toOpenRouterModel(mapped.model || this.defaults.responseModel);
     return mapped;
   }
@@ -54,14 +196,6 @@ class OpenRouterProvider extends OpenAIResponsesProvider {
       file, language, response_format: responseFormat, temperature, prompt,
     });
   }
-
-  async createConversation() {
-    throw new Error('createConversation is not supported by OpenRouterProvider');
-  }
-
-  async listMessages() {
-    throw new Error('listMessages is not supported by OpenRouterProvider');
-  }
 }
 
 module.exports = {

package/lib/clinical/providers/createLLMProvider.js

@@ -6,11 +6,13 @@ const { logger } = require('../../utils/logger');
 const { OpenAIResponsesProvider } = require('./OpenAIResponsesProvider');
 const { OpenRouterProvider } = require('./OpenRouterProvider');
 const { AnthropicProvider } = require('./AnthropicProvider');
+const { GatewayProvider } = require('./GatewayProvider');
 
 const PROVIDER_VARIANTS = {
   responses: OpenAIResponsesProvider,
   openrouter: OpenRouterProvider,
   anthropic: AnthropicProvider,
+  gateway: GatewayProvider,
 };
 
 const VARIANT_API_KEY = {

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/lib/index.d.ts

@@ -273,14 +273,29 @@ declare module '@peopl-health/nexus' {
     constructor(options?: { apiKey?: string; organization?: string; client?: any; defaultModels?: Record<string, string>; conversationManager?: any });
     getVariant(): string;
     getClient(): any;
-    createConversation(options?: any): Promise<any>;
-    listMessages(options?: any): Promise<any>;
     executeRun(options: { thread: any; assistant: any; message?: string; tools?: any[]; config?: any }): Promise<any>;
     runConversation(config?: any): Promise<any>;
     transcribeAudio(options?: any): Promise<any>;
   }
 
-  export function createLLMProvider(config?: { variant?: string; [key: string]: any }): OpenAIResponsesProvider;
+  export class GatewayProvider {
+    constructor(options?: { conversationManager?: any; sessionManager?: any; [key: string]: any });
+    getVariant(): string;
+    executeRun(options: { thread: any; assistant: any; message?: string; tools?: any[]; config?: any }): Promise<any>;
+    runConversation(config?: any): Promise<any>;
+    runStructured(params?: { promptId?: string; presetId?: string; variables?: any; input?: any[]; text?: any; metadata?: any }): Promise<any>;
+  }
+
+  export interface LLMProvider {
+    getVariant(): string;
+    getClient?(): any;
+    executeRun(options: { thread: any; assistant: any; message?: string; tools?: any[]; config?: any }): Promise<any>;
+    runConversation(config?: any): Promise<any>;
+    runStructured?(params?: { promptId?: string; presetId?: string; variables?: any; input?: any[]; text?: any; metadata?: any }): Promise<any>;
+    transcribeAudio?(options?: any): Promise<any>;
+  }
+
+  export function createLLMProvider(config?: { variant?: string; [key: string]: any }): LLMProvider;
 
   // Main Nexus Class
   export interface NexusConfig {
@@ -324,7 +339,7 @@ declare module '@peopl-health/nexus' {
     getMessaging(): NexusMessaging;
     getStorage(): MongoStorage | null;
     getMessageParser(): MessageParser | null;
-    getLLMProvider(): OpenAIResponsesProvider | null;
+    getLLMProvider(): LLMProvider | null;
   }
 
   // Utility Functions

package/lib/index.js

@@ -7,6 +7,7 @@ const {
   OpenAIResponsesProvider,
   OpenRouterProvider,
   AnthropicProvider,
+  GatewayProvider,
   configureOpenAIProvider,
   BaseAssistant,
   registerAssistant,
@@ -201,6 +202,7 @@ module.exports = {
   OpenAIResponsesProvider,
   OpenRouterProvider,
   AnthropicProvider,
+  GatewayProvider,
   BaseAssistant,
   registerAssistant,
   overrideGetAssistantById,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peopl-health/nexus",
-  "version": "5.0.0-dev.453",
+  "version": "5.0.0-dev.458",
   "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
-};