Therapeutic feedback

import express, { Request, Response } from 'express';

const router = express.Router();

router.post('/', async (req: Request, res: Response): Promise<void> => {
  try {
    const { transcript, emoData } = req.body;

    if (!transcript) {
      res.status(400).json({ error: 'Transcript is required' });
      return;
    }
    
    const emotionData = emoData || {};

    // Format top 3 emotions with scores
    const formattedEmoData = Object.entries(emotionData)
      .sort(([, a], [, b]) => (b as number) - (a as number))
      .slice(0, 3)
      .map(([emotion, score]) => 
        `${emotion}: ${((score as number) * 100).toFixed(1)}%`
      )
      .join('\\n');

    // Load and populate prompt template
    const rawPrompt = process.env.GEMINI_PROMPT;
    const prompt = rawPrompt
      .replace('{{transcript}}', transcript)
      .replace('{{emoData}}', formattedEmoData);

    // Call Gemini API
    const response = await fetch(
      `https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=${apiKey}`,
      {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({
          contents: [{
            parts: [{ text: prompt }]
          }],
          generationConfig: {
            temperature: 0.3,
            topK: 20,
            topP: 0.8,
            maxOutputTokens: 100,
          }
        })
      }
    );

    const data = await response.json();
    
    res.json({
      response: data.candidates[0].content.parts[0].text,
      emotions: emotionData
    });
  } catch (error) {
    res.status(500).json({
      error: 'Unable to process your request at this time'
    });
  }
});

You are a compassionate AI therapist analyzing a conversation.

Transcript:
{{transcript}}

Detected emotions:
{{emoData}}

Provide brief, empathetic therapeutic feedback addressing the emotional state and conversation content.

interface TherapeuticResponse {
  response: string;      // Generated therapeutic feedback
  emotions: Record<string, number>;  // Original emotion scores
}

const CACHE_DURATION = 5 * 60 * 1000; // 5 minutes

interface CacheData {
  entries: Entry[];
  lastUpdated: number;
  lastModified: number;
}

let entriesCache: CacheData | null = null;

async function getEntriesWithCache(): Promise<Entry[]> {
  const stats = await fs.stat(ENTRIES_FILE_PATH);
  const fileModified = stats.mtimeMs;

  // Return cached data if valid
  if (entriesCache && 
      Date.now() - entriesCache.lastUpdated < CACHE_DURATION &&
      entriesCache.lastModified === fileModified) {
    return entriesCache.entries;
  }

  // Read fresh data and update cache
  const entriesData = await fs.readFile(ENTRIES_FILE_PATH, 'utf-8');
  const entries = JSON.parse(entriesData);

  entriesCache = {
    entries,
    lastUpdated: Date.now(),
    lastModified: fileModified
  };

  return entries;
}

interface Emotions {
  [key: string]: number;
}

interface Turn {
  speaker: "user" | "assistant";
  text: string;
  timestamp: string;
  emotions: Emotions;
}

interface Entry {
  conversation_id: string;
  timestamp_ms: number;
  turns: Turn[];
}