@peopl-health/nexus 5.12.3 → 5.12.5

package/lib/controllers/templateController.js

@@ -216,7 +216,6 @@ const submitForApproval = async (req, res) => {
         $set: {
           status: 'PENDING',
           approvalRequest: {
-            sid: response.sid,
             dateSubmitted: validSubmittedDate,
             dateUpdated: validUpdatedDate,
             rejectionReason: response.rejection_reason || ''
@@ -270,7 +269,6 @@ const checkApprovalStatus = async (req, res) => {
             status.approvalRequest.date_created || status.approvalRequest.dateCreated || status.content.dateCreated
           );
           dbTemplate.approvalRequest = {
-            sid: status.approvalRequest.sid,
             dateSubmitted,
             dateUpdated: parseDate(
               status.approvalRequest.date_updated || status.approvalRequest.dateUpdated || status.content.dateUpdated,
@@ -288,7 +286,7 @@ const checkApprovalStatus = async (req, res) => {
         contentSid,
         content: status.content,
         approvalRequest: status.approvalRequest,
-        template: dbTemplate
+        template: dbTemplate ? _formatTemplate(dbTemplate) : null
       });
     } catch (err) {
       // If Twilio check fails but we have DB record, return what we know
@@ -301,7 +299,7 @@ const checkApprovalStatus = async (req, res) => {
             status: dbTemplate.status
           },
           approvalRequest: dbTemplate.approvalRequest,
-          template: dbTemplate,
+          template: _formatTemplate(dbTemplate),
           warning: 'Could not fetch latest status from Twilio'
         });
       }
@@ -412,7 +410,7 @@ const getCompleteTemplate = async (req, res) => {
     
     return res.status(200).json({
       success: true,
-      template
+      template: _formatTemplate(template)
     });
   } catch (error) {
     return handleApiError(res, error, 'Failed to get complete template');

package/lib/fhir/constants/extensionSlugs.js

@@ -25,6 +25,18 @@ const GRADE_EXT = {
   THRESHOLD_CLAUSE: 'grade-threshold-clause',
 };
 
+const MENTION_EXT = {
+  ASSERTION_NEGATED: 'mention-assertion-negated',
+  ASSERTION_HEDGED: 'mention-assertion-hedged',
+  ASSERTION_EXPERIENCER: 'mention-assertion-experiencer',
+  ASSERTION_TEMPORAL: 'mention-assertion-temporal',
+  ASSERTION_CONFIDENCE: 'mention-assertion-confidence',
+  TEMPORALITY: 'mention-temporality',
+  TURN_ID: 'mention-turn-id',
+  SOURCE: 'mention-source',
+  EXTRACTOR_CONFIDENCE: 'mention-extractor-confidence',
+};
+
 const ROUTING_EXT = {
   TURN_ID: 'routing-turn-id',
   DECISION_ID: 'routing-decision-id',
@@ -89,6 +101,7 @@ const RISK_EXT = {
 
 module.exports = {
   SYMPTOM_CASE_EXT,
+  MENTION_EXT,
   ASSESSMENT_EXT,
   GRADE_EXT,
   ROUTING_EXT,

package/lib/fhir/helpers/elementHelper.js

@@ -34,6 +34,10 @@ function notes(...texts) {
   return present.length ? present : null;
 }
 
+function toInstant(value) {
+  return new Date(value).toISOString();
+}
+
 function toIso(value) {
   if (value instanceof Date) return value.toISOString().replace(/\.000Z$/, 'Z');
   const s = String(value);
@@ -50,5 +54,6 @@ module.exports = {
   codeableConcept,
   extension,
   notes,
+  toInstant,
   toIso,
 };

package/lib/fhir/helpers/resourceHelper.js

@@ -2,12 +2,12 @@ const { getDeviceId, getOrganizationId, getSystems } = require('../config/fhirCo
 const { fhirId } = require('./fhirHelper');
 const { identifier, patientReference, reference, codeableConcept, toIso } = require('./elementHelper');
 
-function baseResource(resourceType, id, slug, patientId) {
+function baseResource(resourceType, id, slug, patientId = null) {
   return {
     resourceType,
     id: fhirId(id),
     identifier: [identifier(slug, id)],
-    subject: patientReference(patientId),
+    ...(patientId ? { subject: patientReference(patientId) } : {}),
   };
 }
 
@@ -25,6 +25,11 @@ function provenance({ provenanceId, targetRefs, recordedAt, activity, agentDevic
   };
 }
 
+function problemListCategory() {
+  const code = 'problem-list-item';
+  return codeableConcept(code, { code, system: getSystems().conditionCategory });
+}
+
 function observationCategory(code) {
   const label = code.replace(/-/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase());
   return codeableConcept(label, { code, system: getSystems().observationCategory, display: label });
@@ -33,5 +38,6 @@ function observationCategory(code) {
 module.exports = {
   baseResource,
   provenance,
+  problemListCategory,
   observationCategory,
 };

package/lib/fhir/projections/clinicalMentionProjection.js

@@ -1,65 +1,195 @@
-const { getSystems } = require('../config/fhirConfig');
-const { codeableConcept, extension } = require('../helpers/elementHelper');
+const { getDeviceId, getOrganizationId, getSystems } = require('../config/fhirConfig');
+const { stringifyValue } = require('../utils/normalizeUtils');
+const { fhirId } = require('../helpers/fhirHelper');
+const { reference, patientReference, codeableConcept, extension, toInstant } = require('../helpers/elementHelper');
+const { baseResource, problemListCategory, observationCategory } = require('../helpers/resourceHelper');
 const { MENTION_SLUG } = require('../constants/projectionSlugs');
-const { Observation } = require('../resources/Observation');
-const { Condition } = require('../resources/Condition');
-const { MedicationStatement } = require('../resources/MedicationStatement');
-const { Procedure } = require('../resources/Procedure');
-const { Appointment } = require('../resources/Appointment');
-const { Provenance } = require('../resources/Provenance');
-
-const PROJECTOR_NAME = 'clinicalMention';
+const { MENTION_EXT } = require('../constants/extensionSlugs');
+
 const ACTIVITY_TEXT = 'clinical-mention-extraction';
+const OBSERVED_FIELD_SYSTEM_KEY = 'observedField';
 
 const DEDICATED_AGGREGATE = new Set(['comorbidity', 'allergy', 'performance_status']);
 
-function projectClinicalMention(mention) {
-  const { fact, provenance } = mention;
+const CATEGORY_TO_OBSERVATION_CATEGORY = {
+  symptom: 'survey',
+  lab_value: 'laboratory',
+  emotion: 'survey',
+  indication: 'exam',
+  diagnosis: 'exam',
+};
+
+const DIAGNOSIS_CATEGORIES = new Set(['diagnosis', 'indication']);
 
+function toFhir(mention) {
+  const { fact, provenance } = mention;
   if (DEDICATED_AGGREGATE.has(fact.category)) return [];
+  const primary = primaryResource(mention);
+  return [primary, mentionProvenance(primary, provenance)];
+}
 
-  const assertion = fact.assertion;
-  const extensions = [
-    extension('mention-assertion-negated', { valueBoolean: assertion.negated }),
-    extension('mention-assertion-hedged', { valueBoolean: assertion.hedged }),
-    extension('mention-assertion-experiencer', { valueString: assertion.experiencer }),
-    extension('mention-assertion-temporal', { valueString: assertion.temporal }),
-    extension('mention-assertion-confidence', { valueDecimal: assertion.confidence }),
-  ];
-  if (fact.temporality) {
-    extensions.push(extension('mention-temporality', { valueString: fact.temporality }));
-  }
+const BUILDER_BY_CATEGORY = {
+  medication: medicationStatementResource,
+  adherence: medicationStatementResource,
+  treatment: procedureResource,
+  appointment: appointmentResource,
+};
+
+function primaryResource(mention) {
+  const { fact } = mention;
+  const build = BUILDER_BY_CATEGORY[fact.category];
+  if (build) return build(mention);
+  const currentAffirmedDiagnosis = DIAGNOSIS_CATEGORIES.has(fact.category)
+    && fact.assertion.temporal === 'current'
+    && !fact.assertion.negated;
+  return currentAffirmedDiagnosis ? conditionResource(mention) : observationResource(mention);
+}
 
-  const code = fact.ctcaeTerm
+function mentionCode(fact) {
+  return fact.ctcaeTerm
     ? codeableConcept(fact.canonicalTerm, { code: fact.ctcaeTerm, system: getSystems().ctcae, display: fact.ctcaeTerm })
     : codeableConcept(fact.canonicalTerm);
-  const primary = primaryResource({ fact, provenance, code, extensions });
-  return [primary, Provenance.fromMentionProjection({ target: primary, provenance, activityText: ACTIVITY_TEXT })];
 }
 
-function primaryResource({ fact, provenance, code, extensions }) {
-  const assertion = fact.assertion;
-  const args = { fact, provenance, code, extensions, slug: MENTION_SLUG };
-  if (fact.category === 'medication' || fact.category === 'adherence') {
-    return MedicationStatement.fromMentionProjection(args);
-  }
-  if (fact.category === 'treatment') {
-    return Procedure.fromMentionProjection(args);
+function mentionExtensions(fact) {
+  const { assertion } = fact;
+  const out = [
+    extension(MENTION_EXT.ASSERTION_NEGATED, { valueBoolean: assertion.negated }),
+    extension(MENTION_EXT.ASSERTION_HEDGED, { valueBoolean: assertion.hedged }),
+    extension(MENTION_EXT.ASSERTION_EXPERIENCER, { valueString: assertion.experiencer }),
+    extension(MENTION_EXT.ASSERTION_TEMPORAL, { valueString: assertion.temporal }),
+    extension(MENTION_EXT.ASSERTION_CONFIDENCE, { valueDecimal: assertion.confidence }),
+  ];
+  if (fact.temporality) out.push(extension(MENTION_EXT.TEMPORALITY, { valueString: fact.temporality }));
+  return out;
+}
+
+const quoteNotes = (provenance) => {
+  const quotes = provenance.verbatimQuotes || [];
+  return quotes.length ? quotes.map((text) => ({ text })) : null;
+};
+
+function observationResource({ fact, provenance }) {
+  const categoryCode = CATEGORY_TO_OBSERVATION_CATEGORY[fact.category] || 'exam';
+  const payload = {
+    ...baseResource('Observation', fact.mentionId, MENTION_SLUG, fact.patientId),
+    status: 'preliminary',
+    category: [observationCategory(categoryCode)],
+    code: mentionCode(fact),
+    performer: [patientReference(fact.patientId)],
+    effectiveDateTime: toInstant(fact.reportedAt),
+    issued: toInstant(provenance.recordedAt),
+    extension: mentionExtensions(fact),
+  };
+  if (fact.assertion.negated) {
+    payload.interpretation = [codeableConcept('Negative', { code: 'NEG', system: getSystems().observationInterpretation, display: 'Negative' })];
+    payload.valueCodeableConcept = codeableConcept('Ausente (negado por el paciente)');
   }
-  if (fact.category === 'appointment') {
-    return Appointment.fromMentionProjection(args);
+  const quotes = quoteNotes(provenance);
+  const components = observedFieldComponents(fact.observedFields);
+  if (quotes) payload.note = quotes;
+  if (components.length) payload.component = components;
+  return payload;
+}
+
+function conditionResource({ fact, provenance }) {
+  const systems = getSystems();
+  const verification = fact.assertion.hedged ? 'unconfirmed' : 'provisional';
+  const payload = {
+    ...baseResource('Condition', fact.mentionId, MENTION_SLUG, fact.patientId),
+    clinicalStatus: codeableConcept('active', { code: 'active', system: systems.conditionClinical }),
+    verificationStatus: codeableConcept(verification, { code: verification, system: systems.conditionVerStatus }),
+    category: [problemListCategory()],
+    code: mentionCode(fact),
+    recordedDate: toInstant(provenance.recordedAt),
+    extension: mentionExtensions(fact),
+  };
+  const quotes = quoteNotes(provenance);
+  if (quotes) payload.note = quotes;
+  return payload;
+}
+
+function medicationStatementResource({ fact, provenance }) {
+  const payload = {
+    ...baseResource('MedicationStatement', fact.mentionId, MENTION_SLUG, fact.patientId),
+    status: 'recorded',
+    medication: { concept: mentionCode(fact) },
+    effectiveDateTime: toInstant(fact.reportedAt),
+    extension: mentionExtensions(fact),
+  };
+  const adherence = adherenceFor(fact.assertion);
+  if (adherence) {
+    payload.adherence = {
+      code: codeableConcept(adherence, { code: adherence, system: getSystems().medicationStatementAdherence }),
+    };
   }
-  const currentAffirmedDiagnosis =
-    (fact.category === 'diagnosis' || fact.category === 'indication') &&
-    assertion.temporal === 'current' &&
-    !assertion.negated;
-  if (currentAffirmedDiagnosis) {
-    return Condition.fromMentionProjection(args);
+  const quotes = quoteNotes(provenance);
+  if (quotes) payload.note = quotes;
+  return payload;
+}
+
+function adherenceFor(assertion) {
+  if (assertion.negated) return 'not-taking';
+  if (assertion.temporal === 'historical') return 'stopped';
+  return null;
+}
+
+function procedureResource({ fact, provenance }) {
+  const payload = {
+    ...baseResource('Procedure', fact.mentionId, MENTION_SLUG, fact.patientId),
+    status: fact.assertion.negated ? 'not-done' : 'completed',
+    code: mentionCode(fact),
+    occurrenceDateTime: toInstant(fact.reportedAt),
+    recorder: patientReference(fact.patientId),
+    extension: mentionExtensions(fact),
+  };
+  const quotes = quoteNotes(provenance);
+  if (quotes) payload.note = quotes;
+  return payload;
+}
+
+function appointmentResource({ fact, provenance }) {
+  const payload = {
+    ...baseResource('Appointment', fact.mentionId, MENTION_SLUG),
+    status: fact.assertion.negated ? 'cancelled' : 'proposed',
+    description: fact.canonicalTerm,
+    participant: [{ actor: patientReference(fact.patientId), status: 'accepted' }],
+    extension: mentionExtensions(fact),
+  };
+  const quotes = quoteNotes(provenance);
+  if (quotes) payload.note = quotes;
+  return payload;
+}
+
+function mentionProvenance(target, provenance) {
+  return {
+    resourceType: 'Provenance',
+    id: fhirId(`${provenance.mentionId}-prov`),
+    target: [reference(target.resourceType, target.id)],
+    recorded: toInstant(provenance.recordedAt),
+    agent: [{ who: reference('Device', getDeviceId()), onBehalfOf: reference('Organization', getOrganizationId()) }],
+    activity: codeableConcept(ACTIVITY_TEXT),
+    extension: [
+      extension(MENTION_EXT.TURN_ID, { valueString: provenance.turnId }),
+      extension(MENTION_EXT.SOURCE, { valueString: provenance.source }),
+      extension(MENTION_EXT.EXTRACTOR_CONFIDENCE, { valueDecimal: provenance.extractorConfidence }),
+    ],
+  };
+}
+
+function observedFieldComponents(observedFields) {
+  const components = [];
+  for (const [key, raw] of Object.entries(observedFields || {})) {
+    const text = stringifyValue(raw);
+    if (!text) continue;
+    components.push({
+      code: codeableConcept(key, { code: key, system: getSystems()[OBSERVED_FIELD_SYSTEM_KEY] }),
+      valueString: text,
+    });
   }
-  return Observation.fromMentionProjection(args);
+  return components;
 }
 
 module.exports = {
-  projectClinicalMention,
-  PROJECTOR_NAME,
+  toFhir,
 };

package/lib/fhir/projections/interventionProjection.js

@@ -2,7 +2,7 @@ const { ZodError } = require('zod');
 
 const { getDeviceId } = require('../config/fhirConfig');
 const { fhirId, codeSystemUrl } = require('../helpers/fhirHelper');
-const { identifier, patientReference, reference, recipientReference, codeableConcept, extension, notes, toIso } = require('../helpers/elementHelper');
+const { patientReference, reference, recipientReference, codeableConcept, extension, notes, toIso } = require('../helpers/elementHelper');
 const { baseResource, provenance } = require('../helpers/resourceHelper');
 const { identifierValue, refToId, extValues, referencedId } = require('../helpers/fhirReadHelper');
 const { INTERVENTION_SLUG, INTERVENTION_KIND_SLUG, INTERVENTION_OUTCOME_SLUG } = require('../constants/projectionSlugs');
@@ -79,9 +79,7 @@ function communicationResource(intervention) {
 
 function taskResource(intervention) {
   const payload = withNote({
-    resourceType: 'Task',
-    id: fhirId(intervention.interventionId),
-    identifier: [identifier(INTERVENTION_SLUG, intervention.interventionId)],
+    ...baseResource('Task', intervention.interventionId, INTERVENTION_SLUG),
     status: intervention.outcome === 'pending' ? 'requested' : 'completed',
     intent: 'order',
     code: codeableConcept(intervention.interventionLabel, {

package/lib/fhir/projections/registerProjectors.js

@@ -1,5 +1,4 @@
 const { registerProjector } = require('../services/fhirService');
-const { projectClinicalMention, PROJECTOR_NAME: MENTION_PROJECTOR_NAME } = require('./clinicalMentionProjection');
 const { projectDispatchedEscalation, PROJECTOR_NAME: ESCALATION_PROJECTOR_NAME } = require('./dispatchedEscalationProjection');
 const { projectReminder, PROJECTOR_NAME: REMINDER_PROJECTOR_NAME } = require('./reminderProjection');
 const { projectPatientRisk, PROJECTOR_NAME: RISK_PROJECTOR_NAME } = require('./riskProjection');
@@ -9,7 +8,6 @@ const { projectPalliativeAssessment, PROJECTOR_NAME: PALLIATIVE_PROJECTOR_NAME }
 const { projectPalliativeCarePlan, PROJECTOR_NAME: PALLIATIVE_CAREPLAN_PROJECTOR_NAME } = require('./palliativeCarePlanProjection');
 
 const PROJECTORS = [
-  { name: MENTION_PROJECTOR_NAME, project: projectClinicalMention },
   { name: ESCALATION_PROJECTOR_NAME, project: projectDispatchedEscalation },
   { name: REMINDER_PROJECTOR_NAME, project: projectReminder },
   { name: RISK_PROJECTOR_NAME, project: projectPatientRisk },

package/lib/fhir/projections/routingProjection.js

@@ -53,20 +53,17 @@ const DISPOSITION_CODECS = {
   },
   task: {
     resourceType: 'Task',
-    build: (d) => {
-      const { subject, ...rest } = dispositionBase('Task', d);
-      return {
-        ...rest,
-        status: 'requested',
-        intent: 'order',
-        code: codeableConcept(d.primaryAction),
-        description: d.primaryReason,
-        for: subject,
-        authoredOn: toIso(d.authoredAt),
-        requester: reference('Device', getDeviceId()),
-        ...(d.primaryCaseId ? { reason: caseReason(d.primaryCaseId) } : {}),
-      };
-    },
+    build: (d) => ({
+      ...baseResource('Task', d.dispositionId, ROUTING_DISPOSITION_SLUG),
+      status: 'requested',
+      intent: 'order',
+      code: codeableConcept(d.primaryAction),
+      description: d.primaryReason,
+      for: patientReference(d.patientId),
+      authoredOn: toIso(d.authoredAt),
+      requester: reference('Device', getDeviceId()),
+      ...(d.primaryCaseId ? { reason: caseReason(d.primaryCaseId) } : {}),
+    }),
     actionOf: (r) => ccText(r.code),
     reasonOf: (r) => r.description,
     authoredOf: (r) => r.authoredOn,

package/lib/fhir/projections/symptomCaseProjection.js

@@ -3,7 +3,7 @@ const { ZodError } = require('zod');
 const { getSystems } = require('../config/fhirConfig');
 const { codeSystemUrl } = require('../helpers/fhirHelper');
 const { reference, patientReference, codeableConcept, extension, toIso } = require('../helpers/elementHelper');
-const { baseResource, provenance, observationCategory } = require('../helpers/resourceHelper');
+const { baseResource, provenance, problemListCategory, observationCategory } = require('../helpers/resourceHelper');
 const { extMap, extValues, identifierValue } = require('../helpers/fhirReadHelper');
 const { SYMPTOM_CASE_SLUG, SYMPTOM_ASSESSMENT_SLUG, SYMPTOM_GRADE_SLUG } = require('../constants/projectionSlugs');
 const { SYMPTOM_CASE_EXT, ASSESSMENT_EXT, GRADE_EXT } = require('../constants/extensionSlugs');
@@ -76,7 +76,7 @@ function conditionResource(condition, verification, headAssessmentId) {
     clinicalStatus: codeableConcept(clinicalStatusCode, { code: clinicalStatusCode, system: systems.conditionClinical }),
     verificationStatus: codeableConcept(verificationCode, { code: verificationCode, system: systems.conditionVerStatus }),
     category: [
-      codeableConcept('problem-list-item', { code: 'problem-list-item', system: systems.conditionCategory }),
+      problemListCategory(),
       codeableConcept('PRO-CTCAE patient-reported symptom (agent-tracked case)', { code: 'proctcae-symptom', system: codeSystemUrl('condition-category') }),
     ],
     code,

package/lib/fhir/resources/Condition.js

@@ -1,35 +1,13 @@
 const { getSystems } = require('../config/fhirConfig');
 const { fhirId, codeSystemUrl } = require('../helpers/fhirHelper');
 const { identifier, reference, patientReference, codeableConcept, extension, toIso } = require('../helpers/elementHelper');
+const { problemListCategory } = require('../helpers/resourceHelper');
 
 class Condition {
   constructor(payload) {
     Object.assign(this, payload);
   }
 
-  static fromMentionProjection({ fact, provenance, code, extensions, slug }) {
-    const assertion = fact.assertion;
-    const notes = provenance.verbatimQuotes && provenance.verbatimQuotes.length
-      ? provenance.verbatimQuotes.map((text) => ({ text }))
-      : null;
-    const verification = assertion.hedged ? 'unconfirmed' : 'provisional';
-    const systems = getSystems();
-    const payload = {
-      resourceType: 'Condition',
-      id: fhirId(fact.mentionId),
-      identifier: [identifier(slug, fact.mentionId)],
-      clinicalStatus: codeableConcept('active', { code: 'active', system: systems.conditionClinical }),
-      verificationStatus: codeableConcept(verification, { code: verification, system: systems.conditionVerStatus }),
-      category: [codeableConcept('problem-list-item', { code: 'problem-list-item', system: systems.conditionCategory })],
-      code,
-      subject: patientReference(fact.patientId),
-      recordedDate: new Date(provenance.recordedAt).toISOString(),
-      extension: extensions,
-    };
-    if (notes) payload.note = notes;
-    return new Condition(payload);
-  }
-
   static fromTriageProjection({ sym, code }) {
     const caseId = `${sym.patientId}-${sym.term}`;
     const systems = getSystems();
@@ -40,7 +18,7 @@ class Condition {
       clinicalStatus: codeableConcept('active', { code: 'active', system: systems.conditionClinical }),
       verificationStatus: codeableConcept('provisional', { code: 'provisional', system: systems.conditionVerStatus }),
       category: [
-        codeableConcept('problem-list-item', { code: 'problem-list-item', system: systems.conditionCategory }),
+        problemListCategory(),
         codeableConcept('PRO-CTCAE patient-reported symptom (triage-tracked case)', { code: 'proctcae-symptom', system: codeSystemUrl('condition-category') }),
       ],
       code,

package/lib/fhir/resources/Observation.js

@@ -1,53 +1,13 @@
-const { getSystems } = require('../config/fhirConfig');
 const { fhirId } = require('../helpers/fhirHelper');
 const { identifier, reference, patientReference, codeableConcept, extension, toIso } = require('../helpers/elementHelper');
 const { observationCategory } = require('../helpers/resourceHelper');
 const { GRADE_EXT } = require('../constants/extensionSlugs');
 
-const OBSERVED_FIELD_SYSTEM_KEY = 'observedField';
-
-const CATEGORY_TO_OBSERVATION_CATEGORY = {
-  symptom: 'survey',
-  lab_value: 'laboratory',
-  emotion: 'survey',
-  indication: 'exam',
-  diagnosis: 'exam',
-};
-
 class Observation {
   constructor(payload) {
     Object.assign(this, payload);
   }
 
-  static fromMentionProjection({ fact, provenance, code, extensions, slug }) {
-    const assertion = fact.assertion;
-    const notes = provenance.verbatimQuotes && provenance.verbatimQuotes.length
-      ? provenance.verbatimQuotes.map((text) => ({ text }))
-      : null;
-    const categoryCode = CATEGORY_TO_OBSERVATION_CATEGORY[fact.category] || 'exam';
-    const payload = {
-      resourceType: 'Observation',
-      id: fhirId(fact.mentionId),
-      identifier: [identifier(slug, fact.mentionId)],
-      status: 'preliminary',
-      category: [observationCategory(categoryCode)],
-      code,
-      subject: patientReference(fact.patientId),
-      performer: [patientReference(fact.patientId)],
-      effectiveDateTime: new Date(fact.reportedAt).toISOString(),
-      issued: new Date(provenance.recordedAt).toISOString(),
-      extension: extensions,
-    };
-    if (assertion.negated) {
-      payload.interpretation = [codeableConcept('Negative', { code: 'NEG', system: getSystems().observationInterpretation, display: 'Negative' })];
-      payload.valueCodeableConcept = codeableConcept('Ausente (negado por el paciente)');
-    }
-    if (notes) payload.note = notes;
-    const components = observedFieldComponents(fact.observedFields);
-    if (components.length) payload.component = components;
-    return new Observation(payload);
-  }
-
   static fromTriageProjection({ sym, code, aeCategoryConcept, components, gradeConcept, method, deviceId }) {
     const sid = String(sym.symptomId);
     const payload = {
@@ -95,28 +55,4 @@ class Observation {
   }
 }
 
-function observedFieldComponents(observedFields) {
-  const components = [];
-  for (const [key, raw] of Object.entries(observedFields || {})) {
-    const text = stringifyObserved(raw);
-    if (!text) continue;
-    components.push({
-      code: codeableConcept(key, { code: key, system: getSystems()[OBSERVED_FIELD_SYSTEM_KEY] }),
-      valueString: text,
-    });
-  }
-  return components;
-}
-
-function stringifyObserved(value) {
-  if (value === null || value === undefined) return '';
-  if (Array.isArray(value)) {
-    return value.filter((v) => v !== null && v !== undefined).map((v) => String(v).trim()).filter(Boolean).join('; ');
-  }
-  if (typeof value === 'object') {
-    return Object.entries(value).filter(([, v]) => v !== null && v !== undefined && String(v).trim()).map(([k, v]) => `${k}: ${v}`).join('; ');
-  }
-  return String(value).trim();
-}
-
 module.exports = { Observation };

package/lib/fhir/resources/Provenance.js

@@ -1,29 +1,12 @@
 const { getDeviceId, getOrganizationId } = require('../config/fhirConfig');
 const { fhirId } = require('../helpers/fhirHelper');
-const { extension, reference, codeableConcept, toIso } = require('../helpers/elementHelper');
+const { reference, codeableConcept, toIso } = require('../helpers/elementHelper');
 
 class Provenance {
   constructor(payload) {
     Object.assign(this, payload);
   }
 
-  static fromMentionProjection({ target, provenance, activityText }) {
-    const payload = {
-      resourceType: 'Provenance',
-      id: fhirId(`${provenance.mentionId}-prov`),
-      target: [{ reference: `${target.resourceType}/${target.id}` }],
-      recorded: new Date(provenance.recordedAt).toISOString(),
-      agent: [{ who: reference('Device', getDeviceId()), onBehalfOf: reference('Organization', getOrganizationId()) }],
-      activity: codeableConcept(activityText),
-      extension: [
-        extension('mention-turn-id', { valueString: provenance.turnId }),
-        extension('mention-source', { valueString: provenance.source }),
-        extension('mention-extractor-confidence', { valueDecimal: provenance.extractorConfidence }),
-      ],
-    };
-    return new Provenance(payload);
-  }
-
   static fromDispatchedEscalation({ target, recordedAt, activityText }) {
     return new Provenance({
       resourceType: 'Provenance',

package/lib/fhir/services/clinicalMentionService.js

@@ -1,5 +1,5 @@
-const { PROJECTOR_NAME } = require('../projections/clinicalMentionProjection');
-const { project, storeResources } = require('./fhirService');
+const { toFhir } = require('../projections/clinicalMentionProjection');
+const { storeResources } = require('./fhirService');
 
 async function storeClinicalMentions({ patientId, mentions }) {
   for (const mention of mentions) {
@@ -7,9 +7,7 @@ async function storeClinicalMentions({ patientId, mentions }) {
       throw new Error(`storeClinicalMentions patientId mismatch: expected ${patientId}`);
     }
   }
-  const bundle = project(mentions.map((mention) => ({ name: PROJECTOR_NAME, aggregate: mention })));
-  const resources = bundle.entry.map((entry) => entry.resource);
-  const { stored } = await storeResources(resources);
+  const { stored } = await storeResources(mentions.flatMap(toFhir));
   return { stored: stored.length, ids: stored, patientId };
 }
 

package/lib/fhir/utils/normalizeUtils.js

@@ -15,6 +15,17 @@ const parseList = (value) =>
     .map((entry) => entry.trim())
     .filter(Boolean);
 
+function stringifyValue(value) {
+  if (value === null || value === undefined) return '';
+  if (Array.isArray(value)) {
+    return value.filter((v) => v !== null && v !== undefined).map((v) => String(v).trim()).filter(Boolean).join('; ');
+  }
+  if (typeof value === 'object') {
+    return Object.entries(value).filter(([, v]) => v !== null && v !== undefined && String(v).trim()).map(([k, v]) => `${k}: ${v}`).join('; ');
+  }
+  return String(value).trim();
+}
+
 function termKey(name) {
   return String(name || '')
     .trim()
@@ -29,5 +40,6 @@ module.exports = {
   lookupValue,
   integerId,
   parseList,
+  stringifyValue,
   termKey,
 };

package/lib/index.d.ts

@@ -116,13 +116,13 @@ declare module '@peopl-health/nexus' {
     name: string;
     description?: string;
     parameters?: any;
-    handler: (args: any) => any;
+    handler: (args: any) => string | Promise<string>;
   }
 
   export interface AssistantConfigDefinition {
     extends?: typeof BaseAssistant;
     create?: (this: BaseAssistant, code: string, context?: any) => Promise<any>;
-    tools?: Array<AssistantToolDefinition | { name: string; definition?: any; handler: (args: any) => any }>;
+    tools?: Array<AssistantToolDefinition | { name: string; definition?: any; handler: (args: any) => string | Promise<string> }>;
     setup?: (this: BaseAssistant, context: { assistantId: string; thread?: any; options?: any }) => void;
   }
 
@@ -138,7 +138,7 @@ declare module '@peopl-health/nexus' {
       assistantId?: string;
       thread?: any;
       client?: any;
-      tools?: Array<AssistantToolDefinition | { name: string; definition?: any; handler: (args: any) => any }>;
+      tools?: Array<AssistantToolDefinition | { name: string; definition?: any; handler: (args: any) => string | Promise<string> }>;
       setup?: (context: { assistantId: string; thread?: any; options?: any }) => void;
       status?: string;
     } | any);
@@ -146,9 +146,9 @@ declare module '@peopl-health/nexus' {
     thread: any;
     status: string;
     createdAt: Date;
-    registerTool(definition: AssistantToolDefinition | string, schema?: any, handler?: (args: any) => any): void;
+    registerTool(definition: AssistantToolDefinition | string, schema?: any, handler?: (args: any) => string | Promise<string>): void;
     getToolSchemas(): any[];
-    executeTool(name: string, args: any): Promise<any>;
+    executeTool(name: string, args: any): Promise<string>;
     getPreviousMessages(thread?: any): Promise<Array<{ role: string; content: any }>>;
     createThread(code: string, context?: any): Promise<any>;
     sendMessage(userId: string, message: string, options?: any): Promise<any>;

package/lib/models/templateModel.js

@@ -36,7 +36,6 @@ const TemplateSchema = new mongoose.Schema({
     }
   ],
   approvalRequest: {
-    sid: String,
     dateSubmitted: Date,
     dateUpdated: Date,
     rejectionReason: String

package/lib/services/templateService.js

@@ -15,7 +15,6 @@ const refreshApprovalStatuses = async (templates) => {
           const reqData = approvalInfo.approvalRequest;
           const updateFields = {
             approvalRequest: {
-              sid: reqData.sid,
               dateSubmitted: reqData.dateCreated ? new Date(reqData.dateCreated) : new Date(),
               dateUpdated: reqData.dateUpdated ? new Date(reqData.dateUpdated) : new Date(),
               rejectionReason: reqData.rejectionReason || ''

package/package.json

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

package/lib/fhir/resources/Appointment.js

@@ -1,28 +0,0 @@
-const { fhirId } = require('../helpers/fhirHelper');
-const { identifier, patientReference } = require('../helpers/elementHelper');
-
-class Appointment {
-  constructor(payload) {
-    Object.assign(this, payload);
-  }
-
-  static fromMentionProjection({ fact, provenance, extensions, slug }) {
-    const assertion = fact.assertion;
-    const notes = provenance.verbatimQuotes && provenance.verbatimQuotes.length
-      ? provenance.verbatimQuotes.map((text) => ({ text }))
-      : null;
-    const payload = {
-      resourceType: 'Appointment',
-      id: fhirId(fact.mentionId),
-      identifier: [identifier(slug, fact.mentionId)],
-      status: assertion.negated ? 'cancelled' : 'proposed',
-      description: fact.canonicalTerm,
-      participant: [{ actor: patientReference(fact.patientId), status: 'accepted' }],
-      extension: extensions,
-    };
-    if (notes) payload.note = notes;
-    return new Appointment(payload);
-  }
-}
-
-module.exports = { Appointment };

package/lib/fhir/resources/MedicationStatement.js

@@ -1,42 +0,0 @@
-const { getSystems } = require('../config/fhirConfig');
-const { fhirId } = require('../helpers/fhirHelper');
-const { identifier, patientReference, codeableConcept } = require('../helpers/elementHelper');
-
-class MedicationStatement {
-  constructor(payload) {
-    Object.assign(this, payload);
-  }
-
-  static fromMentionProjection({ fact, provenance, code, extensions, slug }) {
-    const assertion = fact.assertion;
-    const notes = provenance.verbatimQuotes && provenance.verbatimQuotes.length
-      ? provenance.verbatimQuotes.map((text) => ({ text }))
-      : null;
-    const payload = {
-      resourceType: 'MedicationStatement',
-      id: fhirId(fact.mentionId),
-      identifier: [identifier(slug, fact.mentionId)],
-      status: 'recorded',
-      medication: { concept: code },
-      subject: patientReference(fact.patientId),
-      effectiveDateTime: new Date(fact.reportedAt).toISOString(),
-      extension: extensions,
-    };
-    const adherence = adherenceFor(assertion);
-    if (adherence) {
-      payload.adherence = {
-        code: codeableConcept(adherence, { code: adherence, system: getSystems().medicationStatementAdherence }),
-      };
-    }
-    if (notes) payload.note = notes;
-    return new MedicationStatement(payload);
-  }
-}
-
-function adherenceFor(assertion) {
-  if (assertion.negated) return 'not-taking';
-  if (assertion.temporal === 'historical') return 'stopped';
-  return null;
-}
-
-module.exports = { MedicationStatement };

package/lib/fhir/resources/Procedure.js

@@ -1,30 +0,0 @@
-const { fhirId } = require('../helpers/fhirHelper');
-const { identifier, patientReference } = require('../helpers/elementHelper');
-
-class Procedure {
-  constructor(payload) {
-    Object.assign(this, payload);
-  }
-
-  static fromMentionProjection({ fact, provenance, code, extensions, slug }) {
-    const assertion = fact.assertion;
-    const notes = provenance.verbatimQuotes && provenance.verbatimQuotes.length
-      ? provenance.verbatimQuotes.map((text) => ({ text }))
-      : null;
-    const payload = {
-      resourceType: 'Procedure',
-      id: fhirId(fact.mentionId),
-      identifier: [identifier(slug, fact.mentionId)],
-      status: assertion.negated ? 'not-done' : 'completed',
-      code,
-      subject: patientReference(fact.patientId),
-      occurrenceDateTime: new Date(fact.reportedAt).toISOString(),
-      recorder: patientReference(fact.patientId),
-      extension: extensions,
-    };
-    if (notes) payload.note = notes;
-    return new Procedure(payload);
-  }
-}
-
-module.exports = { Procedure };