@peopl-health/nexus 5.9.0-dev.921 → 6.0.0-dev.611

package/lib/clinical/services/composerService.js

@@ -1,59 +0,0 @@
-const { getComposer } = require('../config/subAgentsConfig');
-const { getPromptBlocks } = require('../config/composerConfig');
-
-const { readOutputText } = require('../helpers/clinicalMentionHelper');
-const { safeParse } = require('../../utils/jsonUtils');
-const { logger } = require('../../utils/logger');
-
-function buildUserMessage(intentPayload) {
-  const parts = [];
-  parts.push('## IntentPayload (fuente de verdad)');
-  parts.push(JSON.stringify(intentPayload, null, 2));
-  parts.push('');
-  parts.push('Devuelve SOLO el JSON con `message_text`, `applied_principles`, `reasoning` — sin markdown alrededor.');
-  return parts.join('\n');
-}
-
-async function renderMessage({ intentPayload, provider }) {
-  if (!intentPayload || !provider?.runStructured) return null;
-
-  let presetId;
-  let promptBlocks;
-  try {
-    [{ presetId }, promptBlocks] = await Promise.all([getComposer(), getPromptBlocks()]);
-  } catch (error) {
-    logger.warn('[composerService] composer config load failed; falling back to legacy render', { error: error?.message });
-    return null;
-  }
-  if (!presetId || !promptBlocks) return null;
-
-  const system = `${promptBlocks.skillPrompt}\n\n## Constitución de comunicación\n\n${promptBlocks.constitution}`;
-
-  let result;
-  try {
-    result = await provider.runStructured({
-      presetId,
-      input: [
-        { role: 'system', content: system },
-        { role: 'user', content: buildUserMessage(intentPayload) },
-      ],
-      metadata: { composer: 'patient-message' },
-    });
-  } catch (error) {
-    logger.warn('[composerService] composer render failed; falling back to legacy message_text', { error: error?.message });
-    return null;
-  }
-
-  const outputText = readOutputText(result);
-  const parsed = safeParse(outputText, null);
-  if (outputText && outputText.trim() && parsed === null) {
-    logger.warn('[composerService] composer output did not parse as JSON; falling back to legacy message_text', { presetId });
-  }
-  const messageText = typeof parsed?.message_text === 'string' ? parsed.message_text.trim() : '';
-  if (!messageText) return null;
-  return messageText;
-}
-
-module.exports = {
-  renderMessage,
-};

package/lib/clinical/services/dispatcherService.js

@@ -1,137 +0,0 @@
-const { DispatchedEscalation } = require('../../shared/dtos/DispatchedEscalation');
-const { projectDispatchedEscalation } = require('../../fhir/projections/dispatchedEscalationProjection');
-const { storeResources } = require('../../fhir/services/fhirService');
-
-const SLA_MINUTES_BY_SEVERITY = {
-  critical: 10,
-  high: 30,
-  medium: 240,
-  low: 1440,
-};
-
-const CRISIS_FOLLOWUP_DELAY_MINUTES = 120;
-const CRISIS_FOLLOWUP_PURPOSE = 'crisis_followup_check';
-
-const MEDICAL_URGENCY_TO_SEVERITY = {
-  stat: 'critical',
-  asap: 'high',
-  urgent: 'high',
-  routine: 'medium',
-};
-
-const EMERGENCY_LEVELS = new Set(['stat', 'asap']);
-
-function pageNavigator({ severity, reason }) {
-  return {
-    kind: 'page_navigator',
-    severity,
-    reason,
-    requiresAck: severity === 'critical' || severity === 'high',
-  };
-}
-
-function pageOncologist({ severity, reason }) {
-  return {
-    kind: 'page_oncologist',
-    severity,
-    reason,
-    requiresAck: true,
-  };
-}
-
-function openTicket({ severity, title, reason }) {
-  return {
-    kind: 'open_ticket',
-    severity,
-    title,
-    reason,
-    slaMinutes: SLA_MINUTES_BY_SEVERITY[severity] ?? null,
-  };
-}
-
-function scheduleFollowup({ delayMinutes, purpose, reason, now }) {
-  return {
-    kind: 'schedule_followup',
-    severity: 'medium',
-    reason,
-    fireAt: new Date(new Date(now).getTime() + delayMinutes * 60000).toISOString(),
-    followupPurpose: purpose,
-  };
-}
-
-function planMedicalUrgent(signal) {
-  const level = (signal?.urgencyLevel || 'urgent').toLowerCase();
-  const indicators = Array.isArray(signal?.indicators) ? signal.indicators : [];
-  const label = signal?.category || signal?.symptom || signal?.suspectedCondition || 'medical';
-  if (EMERGENCY_LEVELS.has(level)) {
-    const severity = MEDICAL_URGENCY_TO_SEVERITY[level];
-    const reason = `emergency gate fired: ${indicators.join(', ') || 'unspecified'} (level=${level})`;
-    return [
-      pageOncologist({ severity, reason }),
-      pageNavigator({ severity, reason }),
-      openTicket({ severity, title: `EMERG: ${indicators.join(', ') || 'unspecified'}`, reason }),
-    ];
-  }
-  const severity = MEDICAL_URGENCY_TO_SEVERITY[level] || 'medium';
-  return [
-    openTicket({
-      severity,
-      title: `MED-${level.toUpperCase()}: ${String(label).slice(0, 60)}`,
-      reason: signal?.urgencyJustification || null,
-    }),
-  ];
-}
-
-function planCrisis(signal, now) {
-  const reason = `crisis protocol fired: ${(signal?.signals || []).join(', ') || 'unspecified'}`;
-  return [
-    pageNavigator({ severity: 'critical', reason }),
-    openTicket({ severity: 'critical', title: `CRISIS: ${signal?.crisisLevel || 'unspecified'}`, reason }),
-    scheduleFollowup({ delayMinutes: CRISIS_FOLLOWUP_DELAY_MINUTES, purpose: CRISIS_FOLLOWUP_PURPOSE, reason, now }),
-  ];
-}
-
-function buildPlan({ escalationKind, trace, now }) {
-  const signals = trace?.signals || {};
-  if (escalationKind === 'medical_urgent') return planMedicalUrgent(signals.medicalEscalation);
-  if (escalationKind === 'crisis') return planCrisis(signals.crisis, now);
-  return [];
-}
-
-const RECENT_KEYS_CAP = 5000;
-
-function createDispatcherService() {
-  const recentKeys = new Set();
-
-  async function dispatch({ trace, escalationKind, turnId, patientCode, now = new Date().toISOString() }) {
-    if (!turnId || !patientCode) {
-      throw new Error('dispatch requires non-empty turnId and patientCode');
-    }
-    const plan = buildPlan({ escalationKind, trace, now });
-    const fresh = plan.filter((primitive) => !recentKeys.has(`${turnId}:${escalationKind}:${primitive.kind}`));
-    if (!fresh.length) return { count: 0, ids: [] };
-
-    const dispatched = fresh.map((primitive) => DispatchedEscalation.schema.parse({
-      ...primitive,
-      eventId: `disp_${turnId}_${escalationKind}_${primitive.kind}`,
-      patientId: patientCode,
-      createdAt: now,
-    }));
-
-    const resources = dispatched.flatMap((escalation) => projectDispatchedEscalation(escalation));
-    await storeResources(resources);
-
-    fresh.forEach((primitive) => {
-      recentKeys.add(`${turnId}:${escalationKind}:${primitive.kind}`);
-      if (recentKeys.size > RECENT_KEYS_CAP) recentKeys.delete(recentKeys.values().next().value);
-    });
-    return { count: dispatched.length, ids: dispatched.map((escalation) => escalation.eventId) };
-  }
-
-  return { dispatch };
-}
-
-module.exports = {
-  createDispatcherService,
-  dispatcherService: createDispatcherService(),
-};

package/lib/clinical/services/reminderDispatchService.js

@@ -1,36 +0,0 @@
-const moment = require('moment-timezone');
-
-const { Reminder } = require('../../shared/dtos/Reminder');
-const { PROJECTOR_NAME } = require('../../fhir/projections/reminderProjection');
-const { project, storeResources } = require('../../fhir');
-
-const REMINDER_TYPE_TO_KIND = {
-  medicamento: 'medication',
-  'exámen': 'exam',
-  examen: 'exam',
-  cita: 'appointment',
-  check_in: 'check_in',
-  otros: 'other',
-};
-
-function toReminder({ intent, patientId, authoredAt }) {
-  return new Reminder({
-    reminderId: intent.reminderId,
-    patientId,
-    kind: REMINDER_TYPE_TO_KIND[intent.reminderType] || 'other',
-    message: intent.description,
-    fireAt: moment.tz(intent.fireAt, intent.timeZone).format('YYYY-MM-DDTHH:mm:ssZ'),
-    channel: intent.channel || 'whatsapp',
-    authoredAt,
-  });
-}
-
-async function dispatchReminder({ intent, patientId, authoredAt = new Date().toISOString() }) {
-  const reminder = toReminder({ intent, patientId, authoredAt });
-  const bundle = project([{ name: PROJECTOR_NAME, aggregate: reminder }]);
-  const resources = bundle.entry.map((entry) => entry.resource);
-  const { stored } = await storeResources(resources);
-  return { stored: stored.length, ids: stored };
-}
-
-module.exports = { dispatchReminder };

package/lib/clinical/services/skillService.js

@@ -1,44 +0,0 @@
-const { Config_ID } = require('../../config/airtableConfig');
-
-const { getRecordByFilter } = require('../../services/airtableService');
-
-const MapCache = require('../../utils/MapCache');
-
-const SKILLS_TABLE = 'skills';
-const CACHE_TTL = 5 * 60 * 1000;
-const CACHE_KEY = 'skills';
-
-const cache = new MapCache({ maxSize: 1, ttl: CACHE_TTL });
-
-async function loadSkills() {
-  const cached = cache.get(CACHE_KEY);
-  if (cached) return cached;
-
-  const records = await getRecordByFilter(Config_ID, SKILLS_TABLE, 'TRUE()');
-  if (!records) throw new Error(`skills catalog not readable from Config base: table ${SKILLS_TABLE}`);
-
-  const skillsById = new Map(
-    records.filter((row) => row.skill_id).map((row) => [row.skill_id, row]),
-  );
-  cache.set(CACHE_KEY, skillsById);
-  return skillsById;
-}
-
-async function loadSkillBody(name) {
-  const skillsById = await loadSkills();
-  const row = skillsById.get(name);
-  if (!row) return { skill: null, availableSkills: [...skillsById.keys()] };
-  return { skill: { name: row.skill_id, version: row.version ?? null, body: row.body } };
-}
-
-async function resolveEnabledSkills(presetSkillRecordIds) {
-  if (!Array.isArray(presetSkillRecordIds) || presetSkillRecordIds.length === 0) return [];
-  const formula = `OR(${presetSkillRecordIds.map((id) => `RECORD_ID()="${id}"`).join(',')})`;
-  const records = await getRecordByFilter(Config_ID, SKILLS_TABLE, formula);
-  return (records || []).filter((row) => row.skill_id).map((row) => row.skill_id);
-}
-
-module.exports = {
-  loadSkillBody,
-  resolveEnabledSkills,
-};

package/lib/clinical/tools/analyzeSymptomPatternsTool.js

@@ -1,279 +0,0 @@
-const { readSymptomCases, readPatientRisk } = require('../../fhir');
-
-const _CHECKPOINT_KEYWORDS = [
-  'pembrolizumab', 'nivolumab', 'atezolizumab', 'durvalumab',
-  'ipilimumab', 'cemiplimab', 'avelumab', 'checkpoint',
-];
-
-const _CYTOTOXIC_KEYWORDS = [
-  'folfox', 'folfiri', 'folfirinox', 'ac-t', 'ac ', 'taxol',
-  'paclitaxel', 'doxorub', 'cisplat', 'carboplat', '5-fu',
-  'capecitab', 'gemcitab', 'docetax', 'vincrist', 'etop', 'quimio',
-];
-
-const _PATTERN_CATALOG = [
-  {
-    pattern_id: 'pattern-pneumonitis',
-    type: 'ae_profile',
-    hypothesis_label_suggestion: 'pneumonitis_candidate',
-    treatment_context: 'checkpoint_inhibitor',
-    key_symptoms: ['cough', 'dyspnea', 'fatigue', 'chest_pain_cardiac'],
-    disconfirming_symptoms: [],
-    clinical_significance_if_confirmed: 'emergency',
-    confidence_would_strengthen_if: [
-      'dyspnea reported at any severity',
-      'oxygen saturation drops below baseline',
-      'cough becomes progressive or productive',
-      'chest imaging abnormal',
-    ],
-  },
-  {
-    pattern_id: 'pattern-cinv',
-    type: 'ae_profile',
-    hypothesis_label_suggestion: 'chemotherapy_induced_nausea_vomiting',
-    treatment_context: 'cytotoxic_chemo',
-    key_symptoms: ['nausea', 'vomiting', 'anorexia'],
-    disconfirming_symptoms: [],
-    clinical_significance_if_confirmed: 'moderate',
-    confidence_would_strengthen_if: [
-      'timing within 5 days of chemo cycle',
-      'severity moderate or worse',
-      'functional impact on oral intake',
-    ],
-  },
-  {
-    pattern_id: 'pattern-febrile-syndrome',
-    type: 'symptom_syndrome',
-    hypothesis_label_suggestion: 'febrile_syndrome_suspected',
-    treatment_context: null,
-    key_symptoms: ['fever', 'chills'],
-    disconfirming_symptoms: [],
-    clinical_significance_if_confirmed: 'safety_relevant',
-    confidence_would_strengthen_if: [
-      'temperature measured ≥38.3°C',
-      'patient in neutropenic nadir window',
-      'rigors or night sweats reported',
-    ],
-  },
-  {
-    pattern_id: 'pattern-neuro-constellation',
-    type: 'disease_complication',
-    hypothesis_label_suggestion: 'neuro_constellation',
-    treatment_context: null,
-    key_symptoms: ['headache', 'dizziness'],
-    disconfirming_symptoms: [],
-    clinical_significance_if_confirmed: 'emergency',
-    confidence_would_strengthen_if: [
-      'sudden onset or worst-ever headache',
-      'focal neurological deficit reported',
-      'vision or speech change',
-      'history of CNS metastasis',
-    ],
-  },
-  {
-    pattern_id: 'pattern-cord-compression',
-    type: 'disease_complication',
-    hypothesis_label_suggestion: 'cord_compression_suspected',
-    treatment_context: null,
-    key_symptoms: ['pain', 'peripheral_neuropathy'],
-    disconfirming_symptoms: [],
-    clinical_significance_if_confirmed: 'emergency',
-    confidence_would_strengthen_if: [
-      'new back pain with leg weakness',
-      'bladder or bowel involvement',
-      'history of spine metastasis',
-    ],
-  },
-  {
-    pattern_id: 'pattern-pain-insomnia-fatigue',
-    type: 'relational_causal',
-    hypothesis_label_suggestion: 'pain_insomnia_fatigue_chain',
-    treatment_context: null,
-    key_symptoms: ['pain', 'insomnia', 'fatigue'],
-    disconfirming_symptoms: [],
-    clinical_significance_if_confirmed: 'moderate',
-    confidence_would_strengthen_if: [
-      'temporal sequence confirmed (pain → insomnia → fatigue)',
-      'pain interferes with sleep specifically',
-    ],
-  },
-];
-
-const _SCOPES = ['all_active_cases', 'specific_cases', 'include_recent_resolved'];
-
-const _OPEN_STATUSES = ['characterizing', 'monitoring'];
-
-const _TERMINAL_STATUSES = ['closed', 'resolved', 'inactive'];
-
-const definition = {
-  name: 'analyzeSymptomPatterns',
-  description: '**Does:** VALIDATES a clinical pattern you propose against the patient\'s active symptom landscape + treatment context. You pick a `specific_pattern_to_validate` (one of 6 frozen catalog patterns) from your reasoning over the symptoms + regimen + grades; the tool deterministically confirms whether the data matches. Read-only — never writes.\n\n**Required inputs:** `specific_pattern_to_validate` — one of `pattern-pneumonitis`, `pattern-cinv`, `pattern-febrile-syndrome`, `pattern-neuro-constellation`, `pattern-cord-compression`, `pattern-pain-insomnia-fatigue`. Optional `scope` (`all_active_cases` default | `specific_cases` | `include_recent_resolved`); `specific_case_ids` (required only for `scope=specific_cases`).\n\n**Returns:** `pattern_validated` (bool). When validated: `match` (pattern_id, type, hypothesis_label_suggestion, treatment_context, member_case_ids_matching, key_symptoms_present/missing, disconfirming_symptoms, match_strength, confidence). When not: `pattern_id`, `reason`, `key_symptoms_present[]`, `key_symptoms_missing[]`. Requires ≥2 key-symptom overlaps and a compatible treatment context.',
-  strict: false,
-  parameters: {
-    type: 'object',
-    properties: {
-      specific_pattern_to_validate: {
-        type: 'string',
-        enum: _PATTERN_CATALOG.map((p) => p.pattern_id),
-        description: 'The catalog pattern_id you propose to validate, chosen from your clinical reasoning over the symptom landscape + active regimen + grades.',
-      },
-      scope: {
-        type: 'string',
-        enum: _SCOPES,
-        description: '`all_active_cases` (default): open cases only. `specific_cases`: only the given `specific_case_ids`. `include_recent_resolved`: open cases + cases closed within the last 7 days.',
-      },
-      specific_case_ids: {
-        type: 'array',
-        items: { type: 'string' },
-        description: 'The case ids to validate against. Required for scope=specific_cases; must be absent otherwise.',
-      },
-    },
-    required: ['specific_pattern_to_validate'],
-  },
-};
-
-function fail(error, data = {}) {
-  return JSON.stringify({ success: false, error, data });
-}
-
-function regimenMatchesContext(regimen, context) {
-  if (!context) return true;
-  if (!regimen) return false;
-  const regimenLower = regimen.toLowerCase();
-  if (context === 'checkpoint_inhibitor') return _CHECKPOINT_KEYWORDS.some((keyword) => regimenLower.includes(keyword));
-  if (context === 'cytotoxic_chemo') return _CYTOTOXIC_KEYWORDS.some((keyword) => regimenLower.includes(keyword));
-  return true;
-}
-
-function matchPattern(pattern, activeTerms, termToCases, patientRegimen) {
-  if (!regimenMatchesContext(patientRegimen, pattern.treatment_context)) return null;
-  const keySymptoms = new Set(pattern.key_symptoms || []);
-  const present = [...keySymptoms].filter((term) => activeTerms.has(term)).sort();
-  if (present.length < 2) return null;
-  const missing = [...keySymptoms].filter((term) => !activeTerms.has(term)).sort();
-  const disconfirmingCatalog = new Set(pattern.disconfirming_symptoms || []);
-  const disconfirmingPresent = [...disconfirmingCatalog].filter((term) => activeTerms.has(term)).sort();
-
-  const matchingCaseIds = [];
-  const seen = new Set();
-  for (const term of present) {
-    for (const caseId of termToCases[term] || []) {
-      if (caseId && !seen.has(caseId)) { matchingCaseIds.push(caseId); seen.add(caseId); }
-    }
-  }
-
-  const strength = keySymptoms.size ? Math.round((present.length / keySymptoms.size) * 100) / 100 : 0;
-  const confidence = strength >= 0.75 ? 'strong' : strength >= 0.5 ? 'moderate' : 'speculative';
-
-  return {
-    pattern_id: pattern.pattern_id,
-    type: pattern.type,
-    hypothesis_label_suggestion: pattern.hypothesis_label_suggestion,
-    treatment_context: pattern.treatment_context,
-    member_case_ids_matching: matchingCaseIds,
-    key_symptoms_present: present,
-    key_symptoms_missing: missing,
-    disconfirming_symptoms: disconfirmingPresent,
-    match_strength: strength,
-    confidence,
-    clinical_significance_if_confirmed: pattern.clinical_significance_if_confirmed,
-    confidence_would_strengthen_if: [...(pattern.confidence_would_strengthen_if || [])],
-  };
-}
-
-async function resolveRegimen(patientId) {
-  const risk = await readPatientRisk({ patientId });
-  const regimen = typeof risk?.sourceRegimen === 'string' ? risk.sourceRegimen.trim() : '';
-  return regimen || null;
-}
-
-async function gatherCases({ patientId, scope, specificCaseIds }) {
-  if (scope === 'specific_cases') {
-    const ids = new Set(specificCaseIds || []);
-    const cases = await readSymptomCases({ patientId });
-    return cases.filter((symptomCase) => ids.has(symptomCase.condition.conditionId));
-  }
-  const cases = await readSymptomCases({ patientId });
-  const open = cases.filter((symptomCase) => _OPEN_STATUSES.includes(symptomCase.condition.clinicalStatus));
-  if (scope !== 'include_recent_resolved') return open;
-  const cutoff = Date.now() - 7 * 24 * 60 * 60 * 1000;
-  const recentTerminal = cases.filter((symptomCase) => _TERMINAL_STATUSES.includes(symptomCase.condition.clinicalStatus)
-    && symptomCase.condition.abatementAt && new Date(symptomCase.condition.abatementAt).getTime() >= cutoff);
-  return [...open, ...recentTerminal];
-}
-
-async function handler(args = {}, context = {}) {
-  try {
-    const runtime = context?.toolRuntimeContext || null;
-    if (!runtime?.turnId || !runtime?.patientCode) {
-      return fail('analyzeSymptomPatterns requires an active turn context (turnId, patientCode).');
-    }
-    const specificPattern = typeof args?.specific_pattern_to_validate === 'string' ? args.specific_pattern_to_validate.trim() : '';
-    const knownIds = _PATTERN_CATALOG.map((p) => p.pattern_id);
-    if (!specificPattern) {
-      return fail('specific_pattern_to_validate is required. Pick a pattern_id from your reasoning over the symptom landscape + active regimen + grades, then call this tool to confirm it against the catalog.', { known_pattern_ids: [...knownIds].sort() });
-    }
-    if (!knownIds.includes(specificPattern)) {
-      return fail(`unknown pattern_id: '${specificPattern}'`, { known_pattern_ids: [...knownIds].sort() });
-    }
-
-    const scope = (typeof args?.scope === 'string' ? args.scope : 'all_active_cases').trim().toLowerCase();
-    if (!_SCOPES.includes(scope)) {
-      return fail(`invalid scope: '${scope}'. Must be one of ${_SCOPES.join(' | ')}.`, { scope });
-    }
-    const specificCaseIds = args?.specific_case_ids;
-    if (scope === 'specific_cases') {
-      if (!Array.isArray(specificCaseIds) || !specificCaseIds.length) {
-        return fail('scope=specific_cases requires non-empty specific_case_ids');
-      }
-    } else if (specificCaseIds !== undefined && specificCaseIds !== null && !(Array.isArray(specificCaseIds) && !specificCaseIds.length)) {
-      return fail('specific_case_ids requires scope=specific_cases');
-    }
-
-    const patientId = runtime.patientCode;
-    const matchingCases = await gatherCases({ patientId, scope, specificCaseIds });
-
-    const termToCases = {};
-    const activeTerms = new Set();
-    for (const symptomCase of matchingCases) {
-      const term = (symptomCase.condition.ctcaeTerm || '').trim().toLowerCase();
-      if (!term) continue;
-      activeTerms.add(term);
-      (termToCases[term] = termToCases[term] || []).push(symptomCase.condition.conditionId);
-    }
-
-    const patientRegimen = await resolveRegimen(patientId);
-    const pattern = _PATTERN_CATALOG.find((p) => p.pattern_id === specificPattern);
-    const match = matchPattern(pattern, activeTerms, termToCases, patientRegimen);
-
-    if (match) {
-      return JSON.stringify({ success: true, data: { pattern_validated: true, match } });
-    }
-
-    const contextOk = regimenMatchesContext(patientRegimen, pattern.treatment_context);
-    const keySymptoms = new Set(pattern.key_symptoms || []);
-    const present = [...keySymptoms].filter((t) => activeTerms.has(t)).sort();
-    const missing = [...keySymptoms].filter((t) => !activeTerms.has(t)).sort();
-    const reason = !contextOk
-      ? `treatment-context mismatch: the pattern requires '${pattern.treatment_context}'; patient regimen is '${patientRegimen}'`
-      : `insufficient symptom overlap: ${present.length} of ${keySymptoms.size} key symptoms present (≥2 required)`;
-    return JSON.stringify({
-      success: true,
-      data: {
-        pattern_validated: false,
-        pattern_id: specificPattern,
-        patient_regimen: patientRegimen,
-        reason,
-        key_symptoms_present: present,
-        key_symptoms_missing: missing,
-      },
-    });
-  } catch (err) {
-    return JSON.stringify({ success: false, error: err?.message || 'analyzeSymptomPatterns failed', data: {} });
-  }
-}
-
-module.exports = {
-  definition,
-  handler,
-};