Chapter 06: Clinical Integration

// Example: FHIR Integration for Mental Health AI
import { FHIRClient } from '@wia/mental-002';

class MentalHealthEHRIntegration {
  constructor() {
    this.fhirClient = new FHIRClient({
      baseUrl: 'https://ehr-system.hospital.org/fhir',
      version: 'R4',
      authentication: 'OAuth2',
      clientCredentials: process.env.FHIR_CLIENT_CREDENTIALS
    });
  }

  async retrievePatientData(patientId) {
    // Fetch relevant patient resources from EHR
    const patient = await this.fhirClient.read('Patient', patientId);

    const conditions = await this.fhirClient.search('Condition', {
      patient: patientId,
      category: 'mental-health',
      clinical-status: 'active'
    });

    const medications = await this.fhirClient.search('MedicationStatement', {
      patient: patientId,
      status: 'active',
      category: 'psychiatric'
    });

    const observations = await this.fhirClient.search('Observation', {
      patient: patientId,
      category: 'mental-health',
      date: 'gt' + this.getDateMonthsAgo(6) // Last 6 months
    });

    const questionnaires = await this.fhirClient.search('QuestionnaireResponse', {
      patient: patientId,
      questionnaire: 'PHQ-9|GAD-7|PCL-5', // Mental health screening instruments
      date: 'gt' + this.getDateMonthsAgo(3)
    });

    return {
      demographics: this.extractDemographics(patient),
      diagnoses: this.extractDiagnoses(conditions),
      medications: this.extractMedications(medications),
      priorScreenings: this.extractScreenings(questionnaires),
      vitalSigns: this.extractVitals(observations)
    };
  }

  async submitAIAssessment(patientId, assessment) {
    // Create FHIR Observation resource for AI assessment
    const observation = {
      resourceType: 'Observation',
      status: 'final',
      category: [{
        coding: [{
          system: 'http://terminology.hl7.org/CodeSystem/observation-category',
          code: 'mental-health',
          display: 'Mental Health'
        }]
      }],
      code: {
        coding: [{
          system: 'http://wia.org/fhir/CodeSystem/mental-health-ai',
          code: 'ai-depression-assessment',
          display: 'AI Depression Assessment'
        }],
        text: 'AI-powered depression screening and assessment'
      },
      subject: {
        reference: `Patient/${patientId}`
      },
      effectiveDateTime: new Date().toISOString(),
      performer: [{
        reference: 'Device/mental-health-ai-system',
        display: 'WIA MENTAL-002 AI System'
      }],
      valueCodeableConcept: {
        coding: [{
          system: 'http://snomed.info/sct',
          code: assessment.severityCode,
          display: assessment.severity
        }]
      },
      component: [
        {
          code: {
            coding: [{
              system: 'http://wia.org/fhir/CodeSystem/mental-health-ai',
              code: 'phq9-score',
              display: 'PHQ-9 Score'
            }]
          },
          valueInteger: assessment.phq9Score
        },
        {
          code: {
            coding: [{
              system: 'http://wia.org/fhir/CodeSystem/mental-health-ai',
              code: 'confidence-score',
              display: 'AI Confidence'
            }]
          },
          valueDecimal: assessment.confidence
        },
        {
          code: {
            coding: [{
              system: 'http://wia.org/fhir/CodeSystem/mental-health-ai',
              code: 'risk-level',
              display: 'Risk Level'
            }]
          },
          valueCodeableConcept: {
            coding: [{
              code: assessment.riskLevel,
              display: assessment.riskLevel.toUpperCase()
            }]
          }
        }
      ],
      note: [{
        text: assessment.clinicalNote
      }],
      extension: [{
        url: 'http://wia.org/fhir/StructureDefinition/ai-recommendation',
        valueString: assessment.recommendations
      }]
    };

    // Submit to EHR
    const result = await this.fhirClient.create('Observation', observation);

    // Create Clinical Impression if needed
    if (assessment.requiresClinicalReview) {
      await this.createClinicalImpression(patientId, assessment, result.id);
    }

    return result;
  }

  async createClinicalImpression(patientId, assessment, observationId) {
    const impression = {
      resourceType: 'ClinicalImpression',
      status: 'in-progress',
      subject: {
        reference: `Patient/${patientId}`
      },
      effectiveDateTime: new Date().toISOString(),
      assessor: {
        reference: 'Device/mental-health-ai-system'
      },
      summary: `AI assessment indicates ${assessment.severity} depression. ` +
               `Clinical review recommended. Risk level: ${assessment.riskLevel}.`,
      finding: [{
        itemCodeableConcept: {
          coding: [{
            system: 'http://snomed.info/sct',
            code: '35489007',
            display: 'Depressive disorder'
          }]
        },
        basis: `Based on AI analysis of patient data and screening responses. ` +
               `PHQ-9 score: ${assessment.phq9Score}. ` +
               `Confidence: ${(assessment.confidence * 100).toFixed(0)}%.`
      }],
      investigation: [{
        code: {
          text: 'AI Assessment'
        },
        item: [{
          reference: `Observation/${observationId}`
        }]
      }],
      note: [{
        text: assessment.recommendations
      }]
    };

    return await this.fhirClient.create('ClinicalImpression', impression);
  }

  async queryAlertsAndReminders(clinicianId) {
    // Retrieve patient alerts generated by AI
    const tasks = await this.fhirClient.search('Task', {
      owner: `Practitioner/${clinicianId}`,
      status: 'requested',
      code: 'mental-health-review'
    });

    const alerts = tasks.entry?.map(entry => ({
      patientId: entry.resource.for.reference.split('/')[1],
      priority: entry.resource.priority,
      description: entry.resource.description,
      reason: entry.resource.reasonReference?.display,
      created: entry.resource.authoredOn
    })) || [];

    return alerts.sort((a, b) =>
      this.priorityOrder(a.priority) - this.priorityOrder(b.priority)
    );
  }

  priorityOrder(priority) {
    const order = { 'stat': 0, 'asap': 1, 'urgent': 2, 'routine': 3 };
    return order[priority] || 4;
  }
}