@peopl-health/nexus 3.14.1 → 3.15.1

package/README.md

@@ -175,21 +175,6 @@ You can configure Nexus via environment variables or at runtime using simple inj
 
 Injection points (dependency injection)
 
-- Message scheduling (use your Agenda/Bull model + scheduler):
-```js
-const { configureMessageController } = require('@peopl-health/nexus/lib/controllers/messageController');
-const { AgendaMessage } = require('./src/models/agendaMessageModel');
-const { sendScheduledMessage: appSchedule } = require('./src/messaging/scheduledMessageService');
-
-const provider = nexus.getMessaging().getProvider(); // e.g., TwilioProvider
-configureMessageController({
-  ScheduledMessage: AgendaMessage, // must expose create/find/findById/deleteOne
-  sendScheduledMessage: (saved) => appSchedule(provider.twilioClient, saved),
-  // Optional: only if you use bulk‑airtable
-  getRecordByFilter: require('@peopl-health/nexus/lib/services/airtableService').getRecordByFilter
-});
-```
-
 - Media (inject only your bucket name; AWS SDK is loaded by the lib):
 ```js
 const { configureMediaController } = require('@peopl-health/nexus/lib/controllers/mediaController');

package/lib/adapters/TwilioProvider.js

@@ -95,8 +95,10 @@ class TwilioProvider extends MessageProvider {
 
     if (fileUrl && fileType !== 'text') {
       const mediaPrep = await this._prepareOutboundMedia(messageData, formattedCode);
-      const outboundMediaUrl = mediaPrep.mediaUrl || fileUrl;
-      messageParams.mediaUrl = [outboundMediaUrl];
+      if (!contentSid) {
+        const outboundMediaUrl = mediaPrep.mediaUrl || fileUrl;
+        messageParams.mediaUrl = [outboundMediaUrl];
+      }
       if (!messageParams.body || messageParams.body.trim() === '') {
         delete messageParams.body;
       }

package/lib/controllers/messageController.js

@@ -3,48 +3,30 @@ const moment = require('moment-timezone');
 const { logger } = require('../utils/logger');
 
 const { Message } = require('../models/messageModel.js');
-const { ScheduledMessage: DefaultScheduledMessage } = require('../models/agendaMessageModel.js');
+const { ScheduledMessage } = require('../models/agendaMessageModel.js');
 const FlowRouting = require('../models/flowRoutingModel.js');
 
 const { ensureWhatsAppFormat } = require('../helpers/twilioHelper');
 const { ensureFlowTokenInVariables } = require('../helpers/templateFlowControllerHelper');
 
-const { getRecordByFilter: defaultGetRecordByFilter } = require('../services/airtableService');
+const { getRecordByFilter } = require('../services/airtableService');
 
-const {
-  sendMessage: defaultSendMessage,
-  sendScheduledMessage: defaultSendScheduledMessage,
-  getDefaultInstance
-} = require('../core/NexusMessaging');
-
-const dependencies = {
-  ScheduledMessage: DefaultScheduledMessage,
-  getRecordByFilter: defaultGetRecordByFilter,
-  sendScheduledMessage: defaultSendScheduledMessage,
-  sendMessage: defaultSendMessage
-};
-
-const configureMessageController = (overrides = {}) => {
-  Object.keys(overrides).forEach(key => {
-    if (overrides[key]) dependencies[key] = overrides[key];
-  });
-  return { ...dependencies };
-};
+const { sendMessage, sendScheduledMessage, getDefaultInstance } = require('../core/NexusMessaging');
 
 const _validateMessagingDeps = (res, requireAirtable = false) => {
-  if (!dependencies.ScheduledMessage) {
+  if (!ScheduledMessage) {
     res.status(500).json({ success: false, error: 'ScheduledMessage model not configured' });
     return false;
   }
-  if (!dependencies.sendScheduledMessage && !dependencies.sendMessage) {
+  if (!sendScheduledMessage && !sendMessage) {
     res.status(500).json({ success: false, error: 'No messaging provider configured' });
     return false;
   }
-  if ((dependencies.sendMessage === defaultSendMessage || dependencies.sendScheduledMessage === defaultSendScheduledMessage) && !getDefaultInstance()) {
+  if (!getDefaultInstance()) {
     res.status(500).json({ success: false, error: 'NexusMessaging not initialized' });
     return false;
   }
-  if (requireAirtable && !dependencies.getRecordByFilter) {
+  if (requireAirtable && !getRecordByFilter) {
     res.status(500).json({ success: false, error: 'Airtable getRecordByFilter not configured' });
     return false;
   }
@@ -56,11 +38,11 @@ const _pickMessageId = (result, fallback) =>
   fallback?.wa_id || fallback?.sid || fallback?.id || fallback?._id?.toString() || null;
 
 const _sendAndPersist = async (payload) => {
-  const saved = await dependencies.ScheduledMessage.create(payload);
+  const saved = await ScheduledMessage.create(payload);
 
-  const result = dependencies.sendScheduledMessage
-    ? await dependencies.sendScheduledMessage(saved)
-    : await dependencies.sendMessage({ ...payload, body: payload.message });
+  const result = sendScheduledMessage
+    ? await sendScheduledMessage(saved)
+    : await sendMessage({ ...payload, body: payload.message });
   return { result, saved };
 };
 
@@ -168,7 +150,7 @@ const sendBulkMessageAirtableController = async (req, res) => {
 
   try {
     const isFlowTemplate = contentSid && await FlowRouting.findOne({ contentSid }).lean();
-    const rows = await dependencies.getRecordByFilter(baseId, tableName, condition);
+    const rows = await getRecordByFilter(baseId, tableName, condition);
     let extraDelay = 0;
     const sentPhones = new Set();
     const payloads = [];
@@ -235,12 +217,12 @@ const checkScheduledMessageStatusController = async (req, res) => {
   if (!contentSid || !code) {
     return res.status(400).json({ success: false, error: 'contentSid and code are required' });
   }
-  if (!dependencies.ScheduledMessage) {
+  if (!ScheduledMessage) {
     return res.status(500).json({ success: false, error: 'ScheduledMessage model not configured' });
   }
 
   try {
-    const msg = await dependencies.ScheduledMessage.findOne({ contentSid, code: ensureWhatsAppFormat(code) });
+    const msg = await ScheduledMessage.findOne({ contentSid, code: ensureWhatsAppFormat(code) });
     if (!msg) {
       return res.status(404).json({ success: false, error: 'ScheduledMessage not found' });
     }
@@ -278,6 +260,5 @@ module.exports = {
   sendBulkMessageAirtableController,
   getLastInteractionController,
   checkScheduledMessageStatusController,
-  checkMessageStatusController,
-  configureMessageController
+  checkMessageStatusController
 };

package/lib/jobs/BaseJob.js

@@ -0,0 +1,29 @@
+class BaseJob {
+  constructor({ queueAdapter, queueName } = {}) {
+    if (!queueAdapter) {
+      throw new Error(`${this.constructor.name} requires queueAdapter`);
+    }
+    if (!queueName) {
+      throw new Error(`${this.constructor.name} requires queueName`);
+    }
+
+    this.queueAdapter = queueAdapter;
+    this.queueName = queueName;
+
+    this.queueAdapter.process(queueName, (data) => this._process(data));
+  }
+
+  async _enqueue(payload, options = {}) {
+    return await this.queueAdapter.enqueue(this.queueName, payload, options);
+  }
+
+  async _cancelJob(jobId) {
+    return await this.queueAdapter.cancelJob(jobId);
+  }
+
+  async _process(_data) {
+    throw new Error(`${this.constructor.name}: _process(data) must be implemented`);
+  }
+}
+
+module.exports = { BaseJob };

package/lib/jobs/ScheduledMessageJob.js

@@ -0,0 +1,56 @@
+const { logger } = require('../utils/logger');
+const { BaseJob } = require('./BaseJob');
+
+const QUEUE_NAME = 'scheduled-messages';
+
+const DEFAULT_JOB_OPTIONS = {
+  attempts: 3,
+  backoff: { type: 'exponential', delay: 2000 },
+  removeOnComplete: true,
+  removeOnFail: 50
+};
+
+class ScheduledMessageJob extends BaseJob {
+  constructor({ queueAdapter } = {}) {
+    super({ queueAdapter, queueName: QUEUE_NAME });
+  }
+
+  async schedule({ scheduledMessageId, sendTime }) {
+    if (!scheduledMessageId) throw new Error('scheduledMessageId is required');
+    if (!sendTime) throw new Error('sendTime is required');
+
+    const delay = Math.max(0, new Date(sendTime).getTime() - Date.now());
+    const jobId = this._buildJobId(scheduledMessageId);
+
+    const enqueuedJobId = await this._enqueue(
+      { scheduledMessageId: String(scheduledMessageId) },
+      { ...DEFAULT_JOB_OPTIONS, delay, jobId }
+    );
+
+    logger.info('[ScheduledMessageJob] Enqueued', { scheduledMessageId, jobId: enqueuedJobId, delay, sendTime });
+
+    return { jobId: enqueuedJobId, delay };
+  }
+
+  async cancel(scheduledMessageId) {
+    if (!scheduledMessageId) throw new Error('scheduledMessageId is required');
+
+    const jobId = this._buildJobId(scheduledMessageId);
+    const cancelled = await this._cancelJob(jobId);
+
+    logger.info('[ScheduledMessageJob] Cancel requested', { scheduledMessageId, jobId, cancelled });
+
+    return cancelled;
+  }
+
+  _buildJobId(scheduledMessageId) {
+    return `scheduled-msg-${scheduledMessageId}`;
+  }
+
+  async _process(data) {
+    logger.warn('[ScheduledMessageJob] Processor stub invoked; real implementation pending', data);
+    return { success: false, reason: 'not_implemented' };
+  }
+}
+
+module.exports = { ScheduledMessageJob };

package/lib/jobs/TemplateApprovalJob.js

@@ -0,0 +1,45 @@
+const { logger } = require('../utils/logger');
+const { BaseJob } = require('./BaseJob');
+
+const QUEUE_NAME = 'template-approval';
+const DEFAULT_DELAY_MS = 15 * 60 * 1000;
+
+const DEFAULT_JOB_OPTIONS = {
+  attempts: 3,
+  backoff: { type: 'exponential', delay: 5000 },
+  removeOnComplete: true,
+  removeOnFail: 50
+};
+
+class TemplateApprovalJob extends BaseJob {
+  constructor({ queueAdapter } = {}) {
+    super({ queueAdapter, queueName: QUEUE_NAME });
+  }
+
+  async schedule({ templateSid, messageId, originalMessageSid = null, attempt = 0, delayMs = DEFAULT_DELAY_MS }) {
+    if (!templateSid) throw new Error('templateSid is required');
+    if (!messageId) throw new Error('messageId is required');
+
+    const jobId = this._buildJobId(templateSid, attempt);
+
+    const enqueuedJobId = await this._enqueue(
+      { templateSid, messageId: String(messageId), originalMessageSid, attempt },
+      { ...DEFAULT_JOB_OPTIONS, delay: delayMs, jobId }
+    );
+
+    logger.info('[TemplateApprovalJob] Enqueued', { templateSid, messageId, attempt, jobId: enqueuedJobId, delayMs });
+
+    return { jobId: enqueuedJobId };
+  }
+
+  _buildJobId(templateSid, attempt) {
+    return `template-approval-${templateSid}-${attempt}`;
+  }
+
+  async _process(data) {
+    logger.warn('[TemplateApprovalJob] Processor stub invoked; real implementation pending', data);
+    return { success: false, reason: 'not_implemented' };
+  }
+}
+
+module.exports = { TemplateApprovalJob };

package/lib/providers/OpenAIResponsesProvider.js

@@ -328,6 +328,7 @@ class OpenAIResponsesProvider {
       presetToolIds,
       presetId: resolvedPresetId,
       presetVersion: resolvedPresetVersion,
+      modelConfig,
     } = await composePrompt({
       presetId,
       presetVersion,
@@ -392,11 +393,15 @@ class OpenAIResponsesProvider {
     if (promptVersion) promptConfig.version = String(promptVersion);
 
     const apiCallConfig = {
-      prompt: promptConfig,
+      ...modelConfig,
       instructions: instructions || additionalInstructions || devContent || '',
       metadata,
       tool_choice: prePromptResult?.toolChoice || toolChoice
     };
+
+    if (!resolvedPresetId) {
+      apiCallConfig.prompt = promptConfig;
+    }
     if (activeToolSchemas.length > 0) {
       apiCallConfig.tools = activeToolSchemas.map(schema => {
         if (schema.type === 'function' && schema.function) {
@@ -453,6 +458,7 @@ class OpenAIResponsesProvider {
       preset_id: resolvedPresetId,
       preset_version: resolvedPresetVersion,
       preset: resolvedPresetId ? { id: resolvedPresetId, version: resolvedPresetVersion } : null,
+      model_config: modelConfig || null,
     };
     return result;
   }

package/lib/services/promptComposerService.js

@@ -78,6 +78,7 @@ async function composePrompt({ presetId = null, presetVersion = null, promptId =
   let presetSnippetIds = null;
   let presetToolIds = null;
   let resolvedPresetVersion = null;
+  let modelConfig = null;
 
   async function applyPreset(id, version = null) {
     const preset = await fetchPreset(id, version);
@@ -88,6 +89,14 @@ async function composePrompt({ presetId = null, presetVersion = null, promptId =
     presetSnippetIds = preset.snippets || [];
     presetToolIds = preset.tools || [];
     resolvedPresetVersion = preset.version ? String(preset.version) : null;
+
+    if (preset.model_config) {
+      try {
+        modelConfig = JSON.parse(preset.model_config);
+      } catch (err) {
+        logger.error('[promptComposer] Invalid model_config JSON in preset', { presetId: id, error: err.message });
+      }
+    }
     const promptRecordId = preset.prompt?.[0];
     if (promptRecordId) {
       const promptRecords = await getRecordByFilter(Config_ID, 'responses', `RECORD_ID()="${promptRecordId}"`);
@@ -141,6 +150,7 @@ async function composePrompt({ presetId = null, presetVersion = null, promptId =
     presetToolIds,
     presetId: presetId || null,
     presetVersion: resolvedPresetVersion,
+    modelConfig,
   };
 }
 

package/lib/storage/MongoStorage.js

@@ -53,6 +53,7 @@ class MongoStorage {
           body: values.body,
           media: values.media,
           type: values.interactive_type ? 'interactive' : values.media ? 'media' : 'message',
+          triggeredBy: values.triggeredBy,
           ...(messageData.frontendId && { frontendId: messageData.frontendId })
         }));
       } else {

package/package.json

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