@peopl-health/nexus 6.4.0-dev.18775 → 6.4.0-dev.18776

package/lib/clinical/helpers/doctorPlanHelper.js

@@ -181,6 +181,43 @@ function proposedPlanOf(draft) {
   return { items, studies: [], homeCare: [], note: rests.join('. ') || null, followUp: { kind: 'check_in', hours: DEFAULT_FOLLOW_UP_HOURS.check_in } };
 }
 
+const plain = (text) => String(text ?? '').normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase();
+const URGENCY_WORDS = /\b(urgencias?|urgente|de inmediato|inmediatamente|emergencias?|911|lo antes posible|cuanto antes|no esperes)\b/g;
+const numbersIn = (text, pattern) => new Set([...plain(text).matchAll(pattern)].map((match) => match[1].replace(',', '.')));
+const HOURS = /cada\s+(\d+)\s*h(?:rs?|oras?)?\b/g;
+const DAYS = /por\s+(\d+)\s+dias?/g;
+const MG = /(\d+(?:[.,]\d+)?)\s*mg\b/g;
+
+// The plan's own words, so what the doctor wrote anywhere in it is never flagged.
+const plannedTextOf = (plan) => [
+  ...plan.items.flatMap((item) => [item.drug, item.strength, item.dose, item.frequency, `por ${item.days} dias`]),
+  ...plan.studies.flatMap((study) => [study.name, study.instructions]),
+  ...plan.homeCare,
+  plan.note,
+].filter(Boolean).join('\n');
+
+// What in the assistant's reply strays from the plan, for the team to check; `unplannedDrugs` are the formulary drugs it names beyond the plan.
+function replyIssues(plan, reply, unplannedDrugs = []) {
+  const text = plain(reply);
+  if (!text) return ['no se pudo leer el mensaje enviado'];
+  const planned = plannedTextOf(plan);
+  const issues = [];
+  for (const item of plan.items) {
+    const name = plain(item.drug).split(/[\s/]/)[0];
+    if (name && !text.includes(name)) issues.push(`no menciona ${item.drug}`);
+  }
+  const strays = (pattern) => [...numbersIn(reply, pattern)].filter((value) => !numbersIn(planned, pattern).has(value));
+  for (const value of strays(HOURS)) issues.push(`dice «cada ${value} horas», que no está en el plan`);
+  for (const value of strays(DAYS)) issues.push(`dice «por ${value} días», que no está en el plan`);
+  for (const value of strays(MG)) issues.push(`dice «${value} mg», que no está en el plan`);
+  for (const name of unplannedDrugs) issues.push(`menciona ${name}, que el médico no indicó`);
+  const plannedWords = new Set([...plain(planned).matchAll(URGENCY_WORDS)].map((match) => match[1]));
+  for (const word of new Set([...text.matchAll(URGENCY_WORDS)].map((match) => match[1]))) {
+    if (!plannedWords.has(word)) issues.push(`usa «${word}», que el médico no indicó`);
+  }
+  return issues;
+}
+
 module.exports = {
   approvedInstructions,
   assistantInstructionsOf,
@@ -190,4 +227,6 @@ module.exports = {
   planSummary,
   prescriptionText,
   proposedPlanOf,
+  plannedTextOf,
+  replyIssues,
 };

package/lib/clinical/services/treatmentProposalService.js

@@ -90,10 +90,8 @@ function validateProposal(proposal, context = {}) {
 
 const namesOf = (drug) => [drug.drug, ...drug.drug.split('/'), ...String(drug.brand ?? '').split('/')].map(key).filter((name) => name.length >= 4);
 
-const DRUG_NAMES = [...new Set(TREATMENT_FORMULARY
-  .flatMap((entry) => entry.drugs)
-  .filter((drug) => drug.isPharmacological !== false)
-  .flatMap(namesOf))];
+const FORMULARY_DRUGS = TREATMENT_FORMULARY.flatMap((entry) => entry.drugs).filter((drug) => drug.isPharmacological !== false);
+const DRUG_NAMES = [...new Set(FORMULARY_DRUGS.flatMap(namesOf))];
 
 function resolvedDrugs(proposals) {
   return proposals.filter(Boolean).flatMap((proposal) => {
@@ -107,6 +105,14 @@ function drugsNamedIn(text) {
   return DRUG_NAMES.filter((name) => padded.includes(` ${name} `));
 }
 
+// Drugs the text names that the planned text does not; a brand of a planned drug counts as planned, a combination only when named whole.
+function unplannedDrugsIn(text, plannedText) {
+  const planned = new Set(drugsNamedIn(plannedText));
+  const ownNames = (drug) => [drug.drug, ...String(drug.brand ?? '').split('/')].map(key).filter(Boolean);
+  const allowed = new Set([...planned, ...FORMULARY_DRUGS.filter((drug) => ownNames(drug).some((name) => planned.has(name))).flatMap(namesOf)]);
+  return [...new Set(drugsNamedIn(text).filter((name) => !allowed.has(name)))];
+}
+
 function unproposedDrugsIn(text, proposals) {
   const proposed = new Set(resolvedDrugs(proposals).flatMap(({ drug }) => namesOf(drug)));
   return drugsNamedIn(text).filter((name) => !proposed.has(name));
@@ -132,6 +138,7 @@ module.exports = {
   JUSTIFICATION_KINDS,
   validateProposal,
   unproposedDrugsIn,
+  unplannedDrugsIn,
   drugsNamedIn,
   crossSymptomIssues,
 };

package/lib/index.d.ts

@@ -274,7 +274,7 @@ declare module '@peopl-health/nexus' {
     initializeLlmMonitor(): Promise<{ enabled: boolean; error?: string } | undefined>;
     getWorkflowRunner(): WorkflowRunner;
     processInstruction(code: string, instruction: string, role?: string, options?: { triggeredBy?: string; beforeRun?: () => Promise<string | null | undefined> | string | null | undefined; dedupeWithinMs?: number }): Promise<{ outcome: string | null; reason?: string; error?: string }>;
-    processSystemMessage(code: string, messages: string | string[], role?: string, options?: { triggeredBy?: string; reply?: boolean }): Promise<{ delivery: Record<string, unknown> | null; sendThrew: boolean } | undefined>;
+    processSystemMessage(code: string, messages: string | string[], role?: string, options?: { triggeredBy?: string; reply?: boolean }): Promise<{ delivery: Record<string, unknown> | null; sendThrew: boolean; reply: string | null } | undefined>;
     processOutreach(code: string, options?: { brief?: OutreachBrief | null; triggeredBy?: string | null; reason?: string | null; firstName?: string | null; dryRun?: boolean; replyToContact?: boolean; allowFollowUp?: boolean }): Promise<OutreachDecision>;
     processCheckInDue(code: string, options: { reminderId: string; type: 'contingencia' | 'seguimiento'; question?: string; firstName?: string | null }): Promise<CheckInDueResult>;
     processScheduledFollowUp(code: string, options: { reminderId: string; firstName: string; now?: Date }): Promise<ScheduledFollowUpResult>;

package/lib/models/escalationReviewModel.js

@@ -245,6 +245,7 @@ const patientDeliverySchema = new mongoose.Schema({
   status: { type: String, default: null },
   transport: { type: String, enum: ['text', 'template_recovery', 'predefined_template', 'assistant'], required: true },
   prescriptionRecordId: { type: String, default: null },
+  checks: { type: [String], default: undefined },
   deferred: { type: Boolean, default: false },
   confirmedBy: { type: String, default: null },
   confirmedAt: { type: Date, default: null },

package/lib/services/assistantMessageService.js

@@ -141,7 +141,7 @@ async function processAssistantSystemMessage(code, messages, role = 'system', op
     throw new AssistantMessageError('MESSAGE_REPLY_FAILED', acceptedCount, error);
   }
   // What the reply's send returned, or null when the turn produced or sent nothing; a send that threw may still have reached the patient.
-  return { delivery: turn?.delivery ?? null, sendThrew: settled === 'threw' };
+  return { delivery: turn?.delivery ?? null, sendThrew: settled === 'threw', reply: turn?.output ?? null };
 }
 
 module.exports = { AssistantMessageError, injectAssistantMessages, processAssistantSystemMessage };

package/lib/services/escalationReviewService.js

@@ -28,13 +28,13 @@ const { isWithin24HourWindow } = require('../helpers/conversationWindowHelper');
 const { ensureWhatsAppFormat } = require('../helpers/twilioHelper');
 const { DrainingError } = require('../core/BatchingManager');
 const { generateEscalationDraft } = require('../clinical/services/escalationDraftService');
-const { conversationLink, writeUnresolvedRequest } = require('../clinical/services/clinicalAirtableService');
+const { conversationLink, readGroupMessageId, writeUnresolvedRequest } = require('../clinical/services/clinicalAirtableService');
 const { doctorAlertHeadline, doctorAlertOpener, renderDoctorMessage, templateSummary, withIdentity } = require('../clinical/helpers/doctorReviewMessageHelper');
 const { generateKeyQuestions } = require('../clinical/services/escalationQuestionsService');
-const { drugsNamedIn } = require('../clinical/services/treatmentProposalService');
+const { drugsNamedIn, unplannedDrugsIn } = require('../clinical/services/treatmentProposalService');
 const { characterizationSeedOf } = require('../clinical/helpers/reviewUpdateHelper');
 const {
-  approvedInstructions, assistantInstructionsOf, needsPrescriber, planInstructions, planOf, planSummary, prescriptionText, proposedPlanOf,
+  approvedInstructions, assistantInstructionsOf, needsPrescriber, planInstructions, planOf, planSummary, prescriptionText, plannedTextOf, proposedPlanOf, replyIssues,
 } = require('../clinical/helpers/doctorPlanHelper');
 const { readNoteFacts, assertionOf } = require('../clinical/services/escalationNoteFactsService');
 const { humanReplyFilter } = require('../clinical/config/safetyNetConfig');
@@ -59,7 +59,7 @@ const { createPrescription } = require('./prescriptionService');
 const { getThreadInfo, switchThreadStoppedStatus } = require('./threadService');
 const { effectiveUrgencyOf, levelsOf, patientTimerMinutes, responseDeadlineOf, responseDeadlinePolicy } = require('./reviewDeadlineService');
 const { caseTaskLive, scheduleCaseSync } = require('./escalationCaseTaskService');
-const { groupConfigured, sendTeamAlert, teamChannelConfigured } = require('./teamAlertService');
+const { groupConfigured, sendGroupNotice, sendTeamAlert, teamChannelConfigured } = require('./teamAlertService');
 
 const getMessaging = () => require('../core/NexusMessaging');
 
@@ -2156,7 +2156,23 @@ function replyOutcome(delivery, sendThrew) {
   return 'unknown';
 }
 
-// The assistant writes the patient message from the doctor's instructions; the review closes unless a follow-up was chosen.
+// A reply in the case's alarm thread; a notice that fails is logged and never undoes the send.
+async function notifyPlanIssues(review, issues) {
+  try {
+    const { patient, doctor, link } = await teamAlertIdentity(review);
+    const header = '⚠️ Revisar el envío del plan';
+    const lines = issues.map((issue) => `- ${issue}`);
+    const action = 'Qué hacer: revisar el chat; corregir con la paciente o volver a mandar la receta si hace falta';
+    const recordId = [...currentAlarms(review)].reverse().find((alarm) => alarm.emergencyRecordId)?.emergencyRecordId;
+    const quoted = await readGroupMessageId(recordId, review.patientCode);
+    const sent = await sendGroupNotice([header, `${patient} (${doctor})`, ...lines, action, link].join('\n'), quoted, [header, ...lines, action].join('\n'));
+    if (!sent.delivered) logger.error('[EscalationReview] The plan check notice did not reach the group', { escalationReviewId: String(review._id), error: sent.error });
+  } catch (error) {
+    logger.error('[EscalationReview] The plan check notice failed', { escalationReviewId: String(review._id), error: redactedError(error) });
+  }
+}
+
+// The assistant writes the patient message from the doctor's instructions; the review closes unless a follow-up was chosen or the reply needs a look.
 async function sendPlanThroughAssistant({ claimed, claim, decisionNumber, plan, operator, requestId }) {
   const reviewId = claimed._id;
   const release = () => releaseReview(reviewId, 'sending', 'approved', claim).catch((releaseError) => {
@@ -2168,9 +2184,10 @@ async function sendPlanThroughAssistant({ claimed, claim, decisionNumber, plan,
   const prescriberEmail = needsPrescriber(plan) ? plan.prescriber?.email ?? null : null;
   let delivery;
   let sendThrew;
+  let reply;
   try {
     if (needsPrescriber(plan) && !prescriberEmail) throw httpError(409, 'This plan names no doctor to sign the receta; record the plan again');
-    ({ delivery = null, sendThrew = false } = await getMessaging().processSystemMessage(
+    ({ delivery = null, sendThrew = false, reply = null } = await getMessaging().processSystemMessage(
       claimed.patientCode, [assistantInstructionsOf(plan)], 'system', { reply: true, triggeredBy: operator },
     ) ?? {});
   } catch (error) {
@@ -2193,25 +2210,30 @@ async function sendPlanThroughAssistant({ claimed, claim, decisionNumber, plan,
   }
   if (outcome === 'unknown') {
     logger.error('[EscalationReview] The assistant reply could not be confirmed; leaving the review in sending', { escalationReviewId: String(reviewId) });
+    await notifyPlanIssues(claimed, ['no se pudo confirmar que el mensaje salió; el caso sigue en «enviando»']);
     throw httpError(502, 'The assistant reply could not be confirmed; check the chat before sending again');
   }
 
   // A queued reply goes out once the patient answers the recovery template; the receta, a template itself, goes now.
   const queued = outcome === 'queued';
   const prescriptionRecordId = prescriberEmail ? await issuePrescription(claimed, plan, prescriberEmail) : null;
+  const prescriptionFailed = Boolean(prescriberEmail) && !prescriptionRecordId;
+  const unplanned = reply ? unplannedDrugsIn(reply, plannedTextOf(plan)) : [];
+  const issues = [...replyIssues(plan, reply, unplanned), ...(prescriptionFailed ? ['no se pudo crear la receta'] : [])];
   const record = {
     decisionNumber, messageId: delivery.messageId || null, status: delivery.status || null, transport: 'assistant', deferred: queued, sentBy: operator,
     ...(prescriptionRecordId && { prescriptionRecordId }),
+    ...(issues.length && { checks: issues }),
   };
   const recordUpdate = withCaseMirror(claimed, { $set: { patientDelivery: record } }, { recommendation: planSummary(plan) });
   const status = queued ? 'indications_queued' : 'indications_sent';
   const review = await completeOperation(reviewId, claim, 'sending', recordUpdate, status);
-  const prescriptionFailed = Boolean(prescriberEmail) && !prescriptionRecordId;
   await audit(review, operator, requestId, {
-    action: status, decisionNumber, transport: 'assistant', ...(prescriberEmail && { prescription: prescriptionFailed ? 'failed' : 'created' }),
+    action: status, decisionNumber, transport: 'assistant', checks: issues.length, ...(prescriberEmail && { prescription: prescriptionFailed ? 'failed' : 'created' }),
   });
-  // Closing waits for a sent reply and the receta it promised; otherwise the team still has something to do.
-  if (plan.followUp.kind === 'none' && !queued && !prescriptionFailed) {
+  if (issues.length) await notifyPlanIssues(review, issues);
+  // Closing waits for a sent reply that kept to the plan and the receta it promised; otherwise the team still has something to do.
+  if (plan.followUp.kind === 'none' && !queued && !issues.length) {
     try {
       return await closeEscalationReview({ id: reviewId, closedBy: operator, requestId });
     } catch (error) {

package/package.json

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