Chapter 04: Support Systems

// Example: AI-Powered CBT Intervention System
import { CBTEngine } from '@wia/mental-002';

class CBTInterventionBot {
  constructor() {
    this.cbt = new CBTEngine({
      approach: 'collaborative-empiricism',
      adaptationLevel: 'personalized',
      evidenceBase: 'clinical-guidelines',
      safetyMonitoring: 'continuous'
    });

    this.interventionModules = {
      thoughtRecording: new ThoughtRecordModule(),
      behavioralActivation: new BehavioralActivationModule(),
      cognitiveRestructuring: new CognitiveRestructuringModule(),
      exposureTherapy: new ExposureTherapyModule(),
      problemSolving: new ProblemSolvingModule()
    };
  }

  async conductSession(userId, sessionContext) {
    // Initialize session
    const session = await this.cbt.initializeSession({
      userId,
      sessionNumber: sessionContext.sessionNumber,
      previousProgress: sessionContext.history,
      currentMood: await this.assessCurrentMood(userId)
    });

    // Agenda setting
    const agenda = await this.setAgenda(session);

    // Homework review (if applicable)
    if (session.sessionNumber > 1) {
      const homeworkReview = await this.reviewHomework(session);
      session.homeworkCompletion = homeworkReview;
    }

    // Core intervention based on treatment plan
    const intervention = await this.deliverIntervention(session, agenda);

    // Skill practice
    const skillPractice = await this.practiceSkills(session, intervention);

    // Assign homework
    const homework = await this.assignHomework(session, intervention);

    // Session summary and feedback
    const summary = await this.summarizeSession({
      session,
      intervention,
      skillPractice,
      homework
    });

    return {
      sessionSummary: summary,
      interventionDelivered: intervention.type,
      skillsPracticed: skillPractice.skills,
      homeworkAssigned: homework,
      progressMetrics: session.progressMetrics,
      nextSessionRecommendations: this.planNextSession(session)
    };
  }

  async deliverIntervention(session, agenda) {
    // Identify primary intervention based on formulation and progress
    const intervention = this.selectIntervention(session);

    switch (intervention.type) {
      case 'thought-recording':
        return await this.thoughtRecordingIntervention(session);

      case 'behavioral-activation':
        return await this.behavioralActivationIntervention(session);

      case 'cognitive-restructuring':
        return await this.cognitiveRestructuringIntervention(session);

      case 'exposure':
        return await this.exposureIntervention(session);

      default:
        return await this.psychoeducationIntervention(session);
    }
  }

  async thoughtRecordingIntervention(session) {
    const conversation = await this.cbt.startConversation({
      template: 'thought-record',
      adaptToUser: session.userProfile
    });

    // Guide through thought record
    const thoughtRecord = {
      situation: null,
      automaticThoughts: [],
      emotions: [],
      emotionIntensity: {},
      evidence: { supporting: [], contradicting: [] },
      alternativeThought: null,
      emotionRerating: {}
    };

    // Situation
    thoughtRecord.situation = await conversation.ask(
      "Let's work on understanding a difficult situation you experienced. " +
      "Can you describe a specific recent situation where you felt upset?"
    );

    // Automatic thoughts
    thoughtRecord.automaticThoughts = await conversation.ask(
      "What thoughts went through your mind in that situation? " +
      "Try to capture the exact words or images that came to mind.",
      { expectMultiple: true }
    );

    // Emotions
    thoughtRecord.emotions = await conversation.ask(
      "What emotions did you feel? You can select multiple.",
      {
        type: 'multiple-choice',
        options: ['Sad', 'Anxious', 'Angry', 'Guilty', 'Ashamed', 'Other'],
        allowOther: true
      }
    );

    // Emotion intensity (0-100 scale)
    for (const emotion of thoughtRecord.emotions) {
      thoughtRecord.emotionIntensity[emotion] = await conversation.ask(
        `How intense was your ${emotion} feeling? (0 = not at all, 100 = extremely intense)`,
        { type: 'scale', min: 0, max: 100 }
      );
    }

    // Evidence examination
    thoughtRecord.evidence.supporting = await conversation.ask(
      "What evidence supports your automatic thought? " +
      "What facts make you believe this thought might be true?",
      { expectMultiple: true }
    );

    thoughtRecord.evidence.contradicting = await conversation.ask(
      "Now, what evidence contradicts your automatic thought? " +
      "What facts suggest this thought might not be completely accurate?",
      { expectMultiple: true }
    );

    // Alternative thought generation
    thoughtRecord.alternativeThought = await conversation.ask(
      "Based on all the evidence, what would be a more balanced way " +
      "to think about this situation?",
      {
        guidance: "Try to consider all the evidence, not just what supports your original thought."
      }
    );

    // Re-rate emotions
    for (const emotion of thoughtRecord.emotions) {
      thoughtRecord.emotionRerating[emotion] = await conversation.ask(
        `Now that you've developed a more balanced thought, how intense ` +
        `is your ${emotion} feeling? (0-100)`,
        { type: 'scale', min: 0, max: 100 }
      );
    }

    // Provide feedback
    const feedback = this.analyzeThoughtRecord(thoughtRecord);

    await conversation.provide(
      `Great work completing this thought record! I noticed that your ` +
      `${Object.keys(thoughtRecord.emotionRerating)[0]} decreased from ` +
      `${thoughtRecord.emotionIntensity[Object.keys(thoughtRecord.emotionRerating)[0]]} ` +
      `to ${thoughtRecord.emotionRerating[Object.keys(thoughtRecord.emotionRerating)[0]]}. ` +
      `This shows that examining your thoughts and looking at evidence can help ` +
      `change how you feel. ${feedback.additionalGuidance}`
    );

    return {
      type: 'thought-recording',
      thoughtRecord,
      emotionalChange: this.calculateEmotionalChange(thoughtRecord),
      insight: feedback,
      completed: true
    };
  }

  async behavioralActivationIntervention(session) {
    // Implementation of behavioral activation for depression
    const activities = await this.generateActivitySuggestions({
      userProfile: session.userProfile,
      previousActivities: session.history.activities,
      currentMood: session.currentMood,
      values: session.userValues
    });

    const selectedActivity = await this.cbt.ask(
      "Behavioral activation helps combat depression by increasing engagement " +
      "in meaningful activities. Which of these activities would you like to try this week?",
      {
        type: 'choice',
        options: activities.map(a => a.description)
      }
    );

    const activityPlan = await this.createActivityPlan(selectedActivity);

    return {
      type: 'behavioral-activation',
      activityScheduled: activityPlan,
      rationale: "Increasing pleasant and meaningful activities",
      completed: true
    };
  }

  analyzeThoughtRecord(thoughtRecord) {
    const emotionalChange = this.calculateEmotionalChange(thoughtRecord);

    let guidance = "";
    if (emotionalChange.averageReduction > 20) {
      guidance = "You made excellent progress in challenging your thought!";
    } else if (emotionalChange.averageReduction > 0) {
      guidance = "You're making progress. Keep practicing examining evidence.";
    } else {
      guidance = "Sometimes thoughts are hard to change. Let's work together on this more.";
    }

    return {
      emotionalChangePercent: emotionalChange.averageReduction,
      additionalGuidance: guidance,
      recommendContinuedPractice: emotionalChange.averageReduction < 30
    };
  }

  calculateEmotionalChange(thoughtRecord) {
    let totalReduction = 0;
    let count = 0;

    for (const emotion in thoughtRecord.emotionIntensity) {
      const before = thoughtRecord.emotionIntensity[emotion];
      const after = thoughtRecord.emotionRerating[emotion];
      totalReduction += (before - after);
      count++;
    }

    return {
      averageReduction: count > 0 ? totalReduction / count : 0,
      emotions: Object.keys(thoughtRecord.emotionIntensity)
    };
  }
}