@peopl-health/nexus 5.67.0-dev.11929 → 5.67.0-dev.11931

package/lib/clinical/providers/AnthropicProvider.js

@@ -475,14 +475,17 @@ class AnthropicProvider extends BaseLLMProvider {
   // Split placement: the inline copy carries recency on single-round turns, the hoisted developer
   // turn persists once tool results are appended after it on multi-round turns.
   _buildInput({ additionalInstructions, ...rest }) {
-    const input = super._buildInput({ additionalInstructions, ...rest });
-    const pinned = { role: 'developer', content: `${RISK_HEADLINE_MARKER}\n${RISK_HEADLINE_DISCLAIMER}` };
-    const ordered = [...input.filter(i => !i[TAIL_PLACEMENT]), pinned, ...input.filter(i => i[TAIL_PLACEMENT])];
+    const ordered = this._orderRuntimeMessages(super._buildInput({ additionalInstructions, ...rest }));
     if (!additionalInstructions) return ordered;
     const { content } = this._operatorInstructionTurn(additionalInstructions);
     return [...ordered, { role: 'user', content: `${OPERATOR_TURN_PREFIX} ${content}`, type: 'message' }];
   }
 
+  _orderRuntimeMessages(input) {
+    const pinned = { role: 'developer', content: `${RISK_HEADLINE_MARKER}\n${RISK_HEADLINE_DISCLAIMER}` };
+    return [...input.filter(i => !i[TAIL_PLACEMENT]), pinned, ...input.filter(i => i[TAIL_PLACEMENT])];
+  }
+
   _mapModelConfig(modelConfig) {
     const mapped = { ...(modelConfig || {}) };
     if (mapped.max_tokens == null && mapped.max_output_tokens != null) mapped.max_tokens = mapped.max_output_tokens;

package/lib/clinical/providers/BaseLLMProvider.js

@@ -783,6 +783,11 @@ class BaseLLMProvider {
     };
   }
 
+  // Providers that pin runtime messages around the tail-placed block override this.
+  _orderRuntimeMessages(input) {
+    return input;
+  }
+
   _sanitizeInput(input) {
     const isMessage = (item) => !item.type || item.type === 'message';
     const items = (input || []).filter(item => isMessage(item) ? this._hasTextContent(item.content) : true);

package/lib/clinical/providers/GatewayProvider.js

@@ -38,6 +38,11 @@ class GatewayProvider extends BaseLLMProvider {
     return this._sub(vendor)._buildInput(config);
   }
 
+  _orderRuntimeMessages(input, modelConfig = null) {
+    const { vendor } = this._route(modelConfig?.model);
+    return this._sub(vendor)._orderRuntimeMessages(input);
+  }
+
   _route(model) {
     if (!model) return { vendor: 'openai', model: undefined };
     const slash = model.indexOf('/');

package/lib/clinical/services/nutritionPlanService.js

@@ -1,13 +1,18 @@
+const { Config_ID } = require('../../config/airtableConfig');
+const { fieldEquals } = require('../../helpers/airtableFormulaHelper');
+const { getRecordByFilter } = require('../../services/airtableService');
 const { safeParse, isPlainObject } = require('../../utils/jsonUtils');
 const { logger } = require('../../utils/logger');
 const { sanitizeInlineText } = require('../../utils/sanitizerUtils');
-const { composePrompt } = require('./promptComposerService');
+const { withTimeout } = require('../../utils/timeoutUtils');
 
 const NUTRITION_GUIDE_PROMPT_ID = 'nutrition_plan_guide';
 const PLAN_MAX_CHARS = 1500;
 const GUIDE_MAX_CHARS = 2000;
 const ISO_DATE_RX = /^\d{4}-\d{2}-\d{2}$/;
 const GUIDE_TIMEOUT_MS = 3000;
+const GUIDE_REFRESH_MS = 5 * 60 * 1000;
+const GUIDE_RETRY_MS = 30 * 1000;
 
 // Each line of a plan or guide is one kind of indication, so the breaks survive and only each line is flattened.
 function keepLines(text, maxChars) {
@@ -31,44 +36,42 @@ function readPlanSection(section) {
   return { text: typeof text === 'string' ? text : '', reviewBy };
 }
 
-let lastGuide = '';
+// The guide is served from memory and refreshed in the background: only the very first read can hold a
+// turn (up to GUIDE_TIMEOUT_MS), and there is never more than one Airtable read in flight.
+let guide = { text: '', freshUntil: 0 };
 let guideRead = null;
-let readSeq = 0;
-let appliedSeq = 0;
 
-function readGuide() {
+function refreshGuide() {
   if (guideRead) return guideRead;
-  const seq = ++readSeq;
-  const read = composePrompt({ promptId: NUTRITION_GUIDE_PROMPT_ID })
-    .then(({ resolvedPrompt }) => {
-      // A read that hung past a newer one must not overwrite what the newer one found.
-      if (seq > appliedSeq) {
-        appliedSeq = seq;
-        lastGuide = keepLines(resolvedPrompt || '', GUIDE_MAX_CHARS);
-      }
-      return lastGuide;
+  // Read straight from Airtable: the in-memory copy is this guide's only cache.
+  guideRead = getRecordByFilter(Config_ID, 'responses', fieldEquals('prompt_id', NUTRITION_GUIDE_PROMPT_ID))
+    .then((records) => {
+      const text = keepLines(records?.[0]?.content || '', GUIDE_MAX_CHARS);
+      // A missing row reads as empty: keep the last guide and look again soon rather than in five minutes.
+      guide = text
+        ? { text, freshUntil: Date.now() + GUIDE_REFRESH_MS }
+        : { ...guide, freshUntil: Date.now() + GUIDE_RETRY_MS };
     })
     .catch((error) => {
-      logger.warn('[nutritionPlanService] nutrition guide unreadable; using the last one read', { error: error.message });
-      return lastGuide;
+      logger.warn('[nutritionPlanService] nutrition guide unreadable; keeping the last one read', { error: error.message });
+      guide = { ...guide, freshUntil: Date.now() + GUIDE_RETRY_MS };
     })
-    .finally(() => { if (guideRead === read) guideRead = null; });
-  guideRead = read;
-  return read;
+    .finally(() => { guideRead = null; });
+  return guideRead;
 }
 
-// The guide only adds to the plan, so a slow read must not hold the patient's turn,
-// and a read that never settles must not hold every later turn either.
 async function loadNutritionGuide() {
-  let timer;
-  const read = readGuide();
-  const timedOut = new Promise((resolve) => { timer = setTimeout(() => resolve(null), GUIDE_TIMEOUT_MS); });
-  const guide = await Promise.race([read, timedOut]);
-  clearTimeout(timer);
-  if (guide !== null) return guide;
-  if (guideRead === read) guideRead = null;
-  logger.warn('[nutritionPlanService] nutrition guide read timed out; using the last one read', { timeoutMs: GUIDE_TIMEOUT_MS });
-  return lastGuide;
+  if (guide.freshUntil) {
+    if (Date.now() >= guide.freshUntil) refreshGuide();
+    return guide.text;
+  }
+  try {
+    await withTimeout(refreshGuide(), GUIDE_TIMEOUT_MS, 'nutrition guide read');
+  } catch {
+    logger.warn('[nutritionPlanService] first nutrition guide read timed out; plan sent without it for now', { timeoutMs: GUIDE_TIMEOUT_MS });
+    if (!guide.freshUntil) guide = { ...guide, freshUntil: Date.now() + GUIDE_RETRY_MS };
+  }
+  return guide.text;
 }
 
 async function resolveNutritionPlan(section, { now = new Date() } = {}) {
@@ -87,6 +90,8 @@ async function resolveNutritionPlan(section, { now = new Date() } = {}) {
 module.exports = {
   NUTRITION_GUIDE_PROMPT_ID,
   GUIDE_TIMEOUT_MS,
+  GUIDE_REFRESH_MS,
+  GUIDE_RETRY_MS,
   resolveNutritionPlan,
-  _test: { reset: () => { lastGuide = ''; guideRead = null; readSeq = 0; appliedSeq = 0; } },
+  _test: { reset: () => { guide = { text: '', freshUntil: 0 }; guideRead = null; } },
 };

package/lib/clinical/services/promptComposerService.js

@@ -14,8 +14,6 @@ const promptCache = new MapCache({ maxSize: 50, ttl: CACHE_TTL });
 const snippetCache = new MapCache({ maxSize: 200, ttl: CACHE_TTL });
 const toolCache = new MapCache({ maxSize: 50, ttl: CACHE_TTL });
 const presetCache = new MapCache({ maxSize: 50, ttl: CACHE_TTL });
-let promptReadClock = 0;
-let promptCacheEpoch = 0;
 
 async function fetchConfigRecords(table, filter) {
   const records = await getRecordByFilter(Config_ID, table, filter);
@@ -49,17 +47,11 @@ async function fetchPreset(presetId, version = null) {
 async function fetchBasePrompt(promptId) {
   const cacheKey = `prompt:${promptId}`;
   const cached = promptCache.get(cacheKey);
-  if (cached) return cached.record;
+  if (cached) return cached;
 
-  // A result may fill the cache unless a read started later already did, or the cache was cleared meanwhile.
-  const startedAt = ++promptReadClock;
-  const epoch = promptCacheEpoch;
   const records = await getRecordByFilter(Config_ID, 'responses', `{prompt_id} = "${promptId}"`);
   const record = records?.[0] || null;
-  const current = promptCache.get(cacheKey);
-  if (record && epoch === promptCacheEpoch && !(current && current.startedAt > startedAt)) {
-    promptCache.set(cacheKey, { record, startedAt });
-  }
+  if (record) promptCache.set(cacheKey, record);
   return record;
 }
 
@@ -265,7 +257,6 @@ async function resolveTools({ promptId, assistant, presetToolIds = null, status
 
 function clearCache() {
   promptCache.clear();
-  promptCacheEpoch += 1;
   snippetCache.clear();
   toolCache.clear();
   presetCache.clear();

package/lib/eval/EvalProvider.js

@@ -225,17 +225,21 @@ class EvalProvider {
     const clinicalMessage = typeof this.provider._buildClinicalMessage === 'function'
       ? this.provider._buildClinicalMessage(promptVariables, interpolatedVariables)
       : [];
-    const input = this.provider._sanitizeInput([...memoryMessage, ...clinicalMessage, ...convertedMessages]);
     const isContextOnly = this.mode === 'context-only';
 
     const shouldUsePromptRegistry = !presetId && this.provider.supportsPromptRegistry && !!assistantId;
+    const modelConfig = shouldUsePromptRegistry ? {} : this._modelConfig(presetModelConfig);
+    const input = this.provider._orderRuntimeMessages(
+      this.provider._sanitizeInput([...memoryMessage, ...clinicalMessage, ...convertedMessages]),
+      modelConfig,
+    );
 
     return {
       instructions: devContent || '',
       input,
       toolSchemas: isContextOnly ? [] : toolSchemas,
       toolChoice: isContextOnly ? 'none' : this.toolChoice,
-      modelConfig: shouldUsePromptRegistry ? {} : this._modelConfig(presetModelConfig),
+      modelConfig,
       assistant: isContextOnly ? null : assistant,
       phiProcessor: this.phiProcessor,
       promptVariables,

package/package.json

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