@peopl-health/nexus 5.68.10 → 5.68.12

package/lib/clinical/helpers/doctorReviewMessageHelper.js

@@ -21,10 +21,12 @@ function latestAlarm(review) {
 function flagsByStatus(sections) {
   const flags = (Array.isArray(sections?.redFlags) ? sections.redFlags : []).filter((flag) => inlineOf(flag?.flag));
   const named = (present) => flags.filter((flag) => flag.present === present).map((flag) => inlineOf(flag.flag));
+  const pending = flags.filter((flag) => typeof flag.present !== 'boolean');
   return {
     present: named(true),
     absent: named(false),
-    unassessed: flags.filter((flag) => typeof flag.present !== 'boolean').map((flag) => inlineOf(flag.flag)),
+    unassessed: pending.map((flag) => inlineOf(flag.flag)),
+    drugSafety: pending.filter((flag) => flag.blocksDrug !== false).map((flag) => inlineOf(flag.flag)),
   };
 }
 
@@ -49,13 +51,24 @@ function drugOf(symptom, item) {
 
 const proposedDrugs = ({ proposal }) => (proposal?.items ?? []).map((item) => drugOf(proposal.symptom, item)).filter(Boolean);
 
-function proposalLine({ proposal, withheldReason }) {
+function proposalLine({ proposal, withheldReason, conduct, sections }) {
   const drugs = proposedDrugs({ proposal });
-  if (!drugs.length) return `→ Sin propuesta de tratamiento: ${sentence(inlineOf(withheldReason) || 'requiere valoración médica')}`;
+  if (!drugs.length) {
+    const why = [withheldReason, conduct].map(inlineOf).filter(Boolean).map(sentence).join(' ');
+    return `→ Sin propuesta de tratamiento: ${why || 'requiere valoración médica.'}`;
+  }
   const declared = [...(proposal.conditions ?? []), ...(proposal.ruledOut ?? []).map((key) => `descartado ${key}`)]
     .map((key) => inlineOf(key)?.replace(/_/g, ' ')).filter(Boolean);
   const table = formularyFor(proposal.symptom)?.label;
-  return [`→ Propuesta para su aprobación (tabla ${table}): ${sentence(drugs.join('; '))}`, declared.length && `Verificar: ${sentence(declared.join(', '))}`].filter(Boolean).join(' ');
+  const { unassessed, drugSafety } = flagsByStatus(sections);
+  const lead = drugSafety.length
+    ? `→ Propuesta para su aprobación si se confirma sin ${drugSafety.join(', ')} (tabla ${table})`
+    : `→ Propuesta para su aprobación (tabla ${table})`;
+  return [
+    `${lead}: ${sentence(drugs.join('; '))}`,
+    unassessed.length && 'Si algo de lo pendiente es positivo: valoración presencial.',
+    declared.length && `Verificar: ${sentence(declared.join(', '))}`,
+  ].filter(Boolean).join(' ');
 }
 
 function symptomParagraph(entry, fallbackSymptom) {

package/lib/clinical/services/clinicalPatternFloorService.js

@@ -1,3 +1,5 @@
+const crypto = require('crypto');
+
 const { getEscalationPatternFloor } = require('../config/subAgentsConfig');
 const { requireGatewayProvider } = require('../config/llmConfig');
 const { readClinicalProfile } = require('../helpers/clinicalProfileHelper');
@@ -9,13 +11,17 @@ const { isPlainObject, safeParse } = require('../../utils/jsonUtils');
 const { logger } = require('../../utils/logger');
 const { redactDirectIdentifiers } = require('../../utils/sanitizerUtils');
 const { withTimeout } = require('../../utils/timeoutUtils');
+const { composePrompt } = require('./promptComposerService');
 
 const FLOOR_LEVELS = ['asap', 'stat'];
 const PATTERN_NAME = /^[a-z0-9_]{1,64}$/;
 const UNLABELLED_PATTERN = 'sin_etiqueta';
 const MAX_TEXT_LENGTH = 500;
+const MAX_LEVEL_LENGTH = 32;
+const MAX_PATTERN_LENGTH = 64;
+const PROVENANCE_GRACE_MS = 500;
 
-const degraded = (reason) => ({ floor: null, degraded: reason });
+const degraded = (reason, check = null) => ({ floor: null, degraded: reason, check });
 
 function normalizePattern(raw) {
   const name = typeof raw === 'string' ? raw.trim().toLowerCase() : '';
@@ -24,6 +30,32 @@ function normalizePattern(raw) {
 
 const clippedText = (value) => cleanText(value)?.slice(0, MAX_TEXT_LENGTH) || null;
 
+// Which prompt judged this escalation. Prompt text is edited in Airtable without bumping the preset
+// version, so the version alone cannot tell two prompts apart; the hash of the composed prompt can.
+async function promptProvenance(presetId, turnId) {
+  try {
+    // Composed alongside runStructured's own compose, with the same inputs and caches: it names the prompt
+    // the model ran with, though an Airtable edit landing between the two reads could make them differ.
+    const composed = await composePrompt({ presetId });
+    // A missing preset composes to an empty prompt; a hash of nothing would read as real provenance.
+    const promptHash = composed.resolvedPrompt
+      ? crypto.createHash('sha256').update(`${composed.resolvedPrompt}\n${JSON.stringify(composed.modelConfig || null)}`).digest('hex').slice(0, 12)
+      : null;
+    return { presetId, presetVersion: composed.presetVersion || null, promptHash };
+  } catch (error) {
+    logger.warn('[clinicalPatternFloor] The prompt provenance could not be read', { turnId, error: error.message });
+    return { presetId, presetVersion: null, promptHash: null };
+  }
+}
+
+// What the model answered, before validation, so a rejected or empty answer can be audited too.
+const rawOutput = (parsed) => ({
+  minLevel: typeof parsed.min_level === 'string' ? parsed.min_level.slice(0, MAX_LEVEL_LENGTH) : null,
+  pattern: typeof parsed.pattern === 'string' ? parsed.pattern.slice(0, MAX_PATTERN_LENGTH) : null,
+  evidence: clippedText(parsed.evidence),
+  reason: clippedText(parsed.reason),
+});
+
 function buildPatternInput({ profile, details, justification, today }) {
   const indicators = Array.isArray(details.indicators) ? details.indicators.filter((item) => typeof item === 'string' && item.trim()) : [];
   const exposure = buildExposureBlock(profile);
@@ -55,32 +87,42 @@ async function evaluatePatternFloor({ code, turnId, details, justification, prov
     logger.warn('[clinicalPatternFloor] The clinical profile is missing or unreadable; the check is skipped', { turnId, profile: reason });
     return degraded(reason);
   }
+  // Read alongside the model call so the audit never spends the floor's deadline.
+  const pendingProvenance = promptProvenance(presetId, turnId);
   const result = await (provider || requireGatewayProvider()).runStructured({
     presetId,
     input: [{ role: 'user', content: buildPatternInput({ profile, details, justification, today: now.toISOString().slice(0, 10) }) }],
     metadata: { subAgent: 'escalation-pattern-floor', turnId },
   });
+  // Once the model has answered, provenance gets a short grace and is otherwise dropped: a slow
+  // Airtable read must never turn an answer the floor already has into a timeout.
+  const provenance = await withTimeout(pendingProvenance, PROVENANCE_GRACE_MS, 'pattern floor provenance').catch((error) => {
+    logger.warn('[clinicalPatternFloor] The prompt provenance was not ready; the answer is kept without it', { turnId, error: error.message });
+    return { presetId, presetVersion: null, promptHash: null };
+  });
   if (result?.status && result.status !== 'completed') {
     logger.warn('[clinicalPatternFloor] The pattern check did not complete', { turnId, status: result.status });
-    return degraded('incomplete');
+    return degraded('incomplete', { ...provenance, output: null });
   }
   const parsed = safeParse(readStructuredText(result), null);
   if (!isPlainObject(parsed)) {
     logger.warn('[clinicalPatternFloor] The pattern check did not return a JSON object', { turnId });
-    return degraded('malformed_output');
+    return degraded('malformed_output', { ...provenance, output: null });
   }
+  const check = { ...provenance, output: rawOutput(parsed) };
   if (parsed.min_level == null) {
-    if (parsed.pattern == null) return { floor: null, degraded: null };
+    if (parsed.pattern == null) return { floor: null, degraded: null, check };
     logger.warn('[clinicalPatternFloor] The pattern check named a pattern without a level', { turnId, pattern: parsed.pattern });
-    return degraded('missing_level');
+    return degraded('missing_level', check);
   }
   if (!FLOOR_LEVELS.includes(parsed.min_level)) {
     logger.warn('[clinicalPatternFloor] The pattern check returned an unsupported level', { turnId, minLevel: parsed.min_level, pattern: parsed.pattern });
-    return degraded('unsupported_level');
+    return degraded('unsupported_level', check);
   }
   return {
     floor: { level: parsed.min_level, pattern: normalizePattern(parsed.pattern), evidence: clippedText(parsed.evidence), reason: clippedText(parsed.reason) },
     degraded: null,
+    check,
   };
 }
 

package/lib/clinical/services/escalationDraftService.js

@@ -13,7 +13,7 @@ const { logger } = require('../../utils/logger');
 const { arrayArg, safeParse } = require('../../utils/jsonUtils');
 const { withTiming } = require('../../utils/tracingDecorator');
 
-const { crossSymptomIssues, unproposedDrugsIn, validateProposal } = require('./treatmentProposalService');
+const { crossSymptomIssues, drugsNamedIn, unproposedDrugsIn, validateProposal } = require('./treatmentProposalService');
 
 const CONVERSATION_TURNS = 40;
 const TRIAGE_LIMIT = 3;
@@ -22,11 +22,10 @@ const CALL_LOG_LIMIT = 10;
 const trimmed = (value) => String(value ?? '').trim();
 
 function withholdReason(sections) {
-  const { present, unassessed } = flagsByStatus(sections);
+  const { present } = flagsByStatus(sections);
   const modifiers = (Array.isArray(sections?.treatmentModifiers) ? sections.treatmentModifiers : []).map(trimmed).filter(Boolean);
   const reasons = [];
   if (present.length) reasons.push(present.length === 1 ? 'hay una bandera roja presente' : 'hay banderas rojas presentes');
-  if (unassessed.length) reasons.push(unassessed.length === 1 ? 'hay una bandera roja sin evaluar' : 'hay banderas rojas sin evaluar');
   if (modifiers.length) reasons.push(`condición que cambia el algoritmo (${modifiers.join(', ')})`);
   return reasons.join('; ') || null;
 }
@@ -35,8 +34,10 @@ function settleProposal(parsed) {
   const withheld = withholdReason(parsed);
   const raw = parsed?.treatmentProposal;
   const items = Array.isArray(raw?.items) ? raw.items : [];
-  if (withheld) return { proposal: null, withheldReason: withheld, strippedItems: items.length };
-  if (!items.length) return { proposal: null, withheldReason: trimmed(parsed?.proposalWithheldReason) || null, strippedItems: 0 };
+  const stated = trimmed(parsed?.proposalWithheldReason);
+  const conduct = stated && !drugsNamedIn(stated).length ? stated : null;
+  if (withheld) return { proposal: null, withheldReason: withheld, conduct, strippedItems: items.length };
+  if (!items.length) return { proposal: null, withheldReason: null, conduct, strippedItems: 0 };
 
   const conditions = Array.isArray(raw.conditions) ? raw.conditions : [];
   const ruledOut = Array.isArray(raw.ruledOut) ? raw.ruledOut : [];
@@ -154,7 +155,8 @@ async function generateEscalationDraft({
 
   const issues = settled.flatMap((entry) => entry.invalid ?? []);
   if (!issues.length) issues.push(...crossSymptomIssues(proposals));
-  const patientDrugs = unproposedDrugsIn(patientMessage, proposals);
+  const confirmed = settled.filter((entry) => entry.proposal && !flagsByStatus(entry.block).drugSafety.length).map((entry) => entry.proposal);
+  const patientDrugs = unproposedDrugsIn(patientMessage, confirmed);
   if (!issues.length && patientDrugs.length) {
     issues.push(`el mensaje al paciente menciona ${patientDrugs.join(', ')}, que no está en la propuesta de tratamiento`);
   }
@@ -167,7 +169,7 @@ async function generateEscalationDraft({
   const doctorText = composeDoctorBody({
     alarm: alarms[alarms.length - 1] ?? null,
     shared: parsed,
-    symptoms: settled.map(({ block, proposal, withheldReason }) => ({ sections: block, proposal, withheldReason })),
+    symptoms: settled.map(({ block, proposal, withheldReason, conduct }) => ({ sections: block, proposal, withheldReason, conduct })),
   });
 
   if (!doctorText || !patientMessage) {

package/lib/clinical/tools/reportMedicalEscalationTool.js

@@ -349,6 +349,7 @@ async function handler(args, context = {}) {
         ...(patternFloor ? { clinicalPatternFloor: { ...patternFloor, raised: raisedByPattern } } : {}),
         ...(gateCheck?.degraded ? { triageGateFloorDegraded: gateCheck.degraded } : {}),
         ...(patternCheck?.degraded ? { clinicalPatternFloorDegraded: patternCheck.degraded } : {}),
+        ...(patternCheck?.check ? { clinicalPatternFloorCheck: patternCheck.check } : {}),
       },
     });
 

package/package.json

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