gemini-session.js

/**
 * ShatterGlass — Gemini Live API Session Manager
 *
 * Manages bidirectional streaming sessions between the Node.js backend
 * and Google's Gemini Live API using the @google/genai SDK.
 *
 * Supports two auth modes:
 *   1. Google AI Studio: Set GEMINI_API_KEY in .env
 *   2. Vertex AI:        Set GOOGLE_CLOUD_PROJECT + GOOGLE_CLOUD_LOCATION in .env
 */

import { GoogleGenAI, Modality } from '@google/genai';
import { MODEL_NAME, TEXT_MODEL_NAME, getSystemPrompt, buildSystemPrompt } from './config.js';

// ── Initialize SDK (supports both API key and Vertex AI) ─────

let ai;
const useVertexAI = process.env.GOOGLE_CLOUD_PROJECT && process.env.GOOGLE_CLOUD_LOCATION;

if (useVertexAI) {
  // Vertex AI auth — uses ADC (Application Default Credentials)
  ai = new GoogleGenAI({
    vertexai: true,
    project: process.env.GOOGLE_CLOUD_PROJECT,
    location: process.env.GOOGLE_CLOUD_LOCATION,
  });
  console.log(`[Gemini] Using Vertex AI (project: ${process.env.GOOGLE_CLOUD_PROJECT}, location: ${process.env.GOOGLE_CLOUD_LOCATION})`);
} else if (process.env.GEMINI_API_KEY) {
  // Google AI Studio auth — uses API key
  ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
  console.log('[Gemini] Using Google AI Studio (API key)');
} else {
  console.error('[Gemini] No auth configured! Set GEMINI_API_KEY or GOOGLE_CLOUD_PROJECT + GOOGLE_CLOUD_LOCATION');
}

/**
 * Creates a Gemini Live API session and wires it to a WebSocket client.
 */
export async function createGeminiSession(ws, handlers = {}, mode = 'pitch', persona = '', context = '') {
  if (!ai) {
    throw new Error(
      'No Gemini auth configured. Set GEMINI_API_KEY (AI Studio) or GOOGLE_CLOUD_PROJECT + GOOGLE_CLOUD_LOCATION (Vertex AI) in .env'
    );
  }

  // Vertex AI uses different model names than Gemini Live API
  let modelName = process.env.GEMINI_MODEL || MODEL_NAME;
  if (useVertexAI && modelName.includes('preview')) {
    // Auto-map: gemini-2.5-flash-native-audio-preview-12-2025 → gemini-live-2.5-flash-native-audio
    const vertexModel = 'gemini-live-2.5-flash-native-audio';
    console.log(`[Gemini] Vertex AI: mapping model ${modelName} → ${vertexModel}`);
    modelName = vertexModel;
  }

  const isNativeAudio = modelName.toLowerCase().includes('native-audio');
  const systemPrompt = buildSystemPrompt(mode, persona, context);

  console.log(`[Gemini] Creating live session with model: ${modelName}`);
  console.log(`[Gemini] Auth: ${useVertexAI ? 'Vertex AI' : 'API Key'}`);
  console.log(`[Gemini] Native audio model: ${isNativeAudio}`);
  console.log(`[Gemini] Mode: ${mode}`);

  // ── Build config ───────────────────────────────────────────
  // IMPORTANT: Only use fields supported by the raw Gemini API.
  // ADK Python RunConfig fields (proactivity, enable_affective_dialog) are
  // NOT supported by the @google/genai JS SDK and will cause immediate
  // session closure with "Cannot find field" errors.

  const config = {
    responseModalities: [Modality.AUDIO],
    systemInstruction: {
      parts: [{ text: systemPrompt }],
    },
    speechConfig: {
      voiceConfig: {
        prebuiltVoiceConfig: {
          voiceName: 'Orus',
        },
      },
    },
    // Google Search grounding — enables live market data lookup for claim verification
    tools: [{ googleSearch: {} }],
  };

  // Transcription (native audio models only)
  if (isNativeAudio) {
    config.inputAudioTranscription = {};
    config.outputAudioTranscription = {};
  }

  // Context window compression — unlimited session duration
  config.contextWindowCompression = {
    triggerTokens: 100000,
    slidingWindow: {
      targetTokens: 80000,
    },
  };

  // Session resumption — transparent reconnection past 10min timeout
  config.sessionResumption = {};

  let session = null;
  let isOpen = false;
  let closeRequested = false;

  // ── Connect ────────────────────────────────────────────────

  try {
    session = await ai.live.connect({
      model: modelName,
      config,
      callbacks: {
        onopen: () => {
          console.log('[Gemini] Live session opened');
          isOpen = true;
          handlers.onOpen?.();
        },

        onmessage: (message) => {
          try {
            handleGeminiMessage(ws, message, handlers);
          } catch (err) {
            console.error('[Gemini] Error handling message:', err.message);
          }
        },

        onerror: (error) => {
          const msg = error?.message || String(error);
          console.error('[Gemini] Session error:', msg);
          isOpen = false;
          handlers.onError?.(error);
        },

        onclose: (event) => {
          const reason = event?.reason || event?.code || 'unknown';
          console.error(`[Gemini] Session closed: ${reason}`);
          isOpen = false;

          // Provide actionable error messages
          if (typeof reason === 'string') {
            if (reason.includes('API key not valid')) {
              console.error('[Gemini] ❌ Your API key is invalid. Regenerate at https://aistudio.google.com/apikey');
              console.error('[Gemini]    Or switch to Vertex AI: set GOOGLE_CLOUD_PROJECT + GOOGLE_CLOUD_LOCATION in .env');
            } else if (reason.includes('Cannot find field')) {
              console.error('[Gemini] ❌ Config field not supported by the API. Check TROUBLESHOOTING.md Section 1');
            } else if (reason.includes('model') || reason.includes('not found')) {
              console.error(`[Gemini] ❌ Model "${modelName}" not available. Check TROUBLESHOOTING.md Section 7`);
            }
          }

          if (!closeRequested) {
            handlers.onClose?.(event);
          }
        },
      },
    });

    console.log('[Gemini] Connected successfully');
  } catch (err) {
    console.error('[Gemini] Failed to connect:', err.message);
    if (err.message?.includes('API key')) {
      console.error('[Gemini] ❌ API key rejected. Get a new one at https://aistudio.google.com/apikey');
    }
    throw err;
  }

  // ── Return session control object ──────────────────────────

  return {
    sendAudio(pcmBuffer) {
      if (!isOpen || !session) return;
      try {
        const base64Audio = Buffer.from(pcmBuffer).toString('base64');
        session.sendRealtimeInput({
          media: {
            data: base64Audio,
            mimeType: 'audio/pcm;rate=16000',
          },
        });
      } catch (err) {
        console.error('[Gemini] Error sending audio:', err.message);
      }
    },

    sendImage(base64Data, mimeType = 'image/jpeg') {
      if (!isOpen || !session) return;
      try {
        session.sendRealtimeInput({
          media: {
            data: base64Data,
            mimeType,
          },
        });
      } catch (err) {
        console.error('[Gemini] Error sending image:', err.message);
      }
    },

    sendText(text) {
      if (!isOpen || !session) return;
      try {
        session.sendClientContent({
          turns: [{
            role: 'user',
            parts: [{ text }],
          }],
        });
      } catch (err) {
        console.error('[Gemini] Error sending text:', err.message);
      }
    },

    close() {
      closeRequested = true;
      if (session) {
        try {
          isOpen = false;
          session.close();
          console.log('[Gemini] Session closed by server');
        } catch (err) {
          console.error('[Gemini] Error closing session:', err.message);
        }
        session = null;
      }
    },

    isActive: () => isOpen && session !== null,
  };
}

// ── Message Handler ────────────────────────────────────────────

function handleGeminiMessage(ws, message, handlers) {
  if (ws.readyState !== 1) return;

  const sc = message.serverContent;

  // Log non-trivial message keys for debugging transcription issues
  const topKeys = Object.keys(message).filter(k => message[k] != null);
  const scKeys = sc ? Object.keys(sc).filter(k => sc[k] != null) : [];
  if (scKeys.length > 0) {
    const interesting = scKeys.filter(k => k !== 'modelTurn' || !sc.modelTurn?.parts?.every(p => p.inlineData));
    if (interesting.length > 0 && !(interesting.length === 1 && interesting[0] === 'modelTurn')) {
      console.log('[Gemini] serverContent keys:', scKeys.join(', '));
    }
  }
  if (topKeys.some(k => !['serverContent', 'usageMetadata', 'sessionResumptionUpdate'].includes(k))) {
    console.log('[Gemini] Top-level message keys:', topKeys.join(', '));
  }

  // Interrupted — barge-in (process BEFORE audio so the frontend can react immediately)
  if (sc?.interrupted) {
    safeSend(ws, { type: 'interrupted' });
    handlers.onInterrupted?.();
    console.log('[Gemini] ⚡ BARGE-IN — AI interrupted the user');
  }

  // Model content (audio/text parts)
  if (sc?.modelTurn?.parts) {
    for (const part of sc.modelTurn.parts) {
      if (part.inlineData) {
        // ── Fast binary path for audio ──
        // Instead of wrapping the base64 in JSON, decode it to raw bytes
        // and send as a binary WS frame with a 1-byte type header.
        // This eliminates JSON.stringify/parse and base64 re-encoding
        // overhead on every single audio chunk (saves ~5-15ms per chunk).
        try {
          const raw = Buffer.from(part.inlineData.data, 'base64');
          // Header: 0x01 = audio
          const frame = Buffer.allocUnsafe(1 + raw.length);
          frame[0] = 0x01;
          raw.copy(frame, 1);
          if (ws.readyState === 1) {
            ws.send(frame);
          }
        } catch {
          // Fallback to JSON if binary send fails
          safeSend(ws, {
            type: 'audio',
            data: part.inlineData.data,
            mimeType: part.inlineData.mimeType || 'audio/pcm;rate=24000',
          });
        }
        handlers.onAudioOutput?.();
      }
      if (part.text) {
        safeSend(ws, {
          type: 'text',
          text: part.text,
          partial: !sc.turnComplete,
        });
      }
    }
  }

  // Turn complete
  if (sc?.turnComplete) {
    safeSend(ws, { type: 'turn-complete' });
    handlers.onTurnComplete?.();
  }

  // ── Transcription ──────────────────────────────────────────
  // Transcription events live inside serverContent in the Gemini Live API protocol.
  // Also check top-level as a fallback for potential SDK changes.
  const inputTx = sc?.inputTranscription || message.inputTranscription;
  const outputTx = sc?.outputTranscription || message.outputTranscription;

  if (inputTx) {
    const text = inputTx.text;
    const finished = !!inputTx.finished;
    console.log(`[Gemini] 📝 Input transcription (finished=${finished}): "${(text || '').slice(0, 80)}"`);
    if (typeof text === 'string') {
      safeSend(ws, {
        type: 'input-transcription',
        text,
        finished,
      });
      handlers.onInputTranscription?.(text, finished);
    }
  }

  if (outputTx) {
    const text = outputTx.text;
    const finished = !!outputTx.finished;
    console.log(`[Gemini] 📝 Output transcription (finished=${finished}): "${(text || '').slice(0, 80)}"`);
    if (typeof text === 'string') {
      safeSend(ws, {
        type: 'output-transcription',
        text,
        finished,
      });
      handlers.onOutputTranscription?.(text, finished);
    }
  }

  // Usage metadata
  if (message.usageMetadata) {
    safeSend(ws, {
      type: 'usage',
      metadata: message.usageMetadata,
    });
  }

  // Session resumption handle
  if (message.sessionResumptionUpdate) {
    console.log('[Gemini] Session resumption handle updated');
  }

  // Google Search tool call / response (grounding)
  if (message.toolCall) {
    console.log('[Gemini] 🔍 Tool call received:', JSON.stringify(message.toolCall).slice(0, 200));
  }
  if (message.toolCallCancellation) {
    console.log('[Gemini] Tool call cancelled');
  }
}

function safeSend(ws, data) {
  if (ws.readyState === 1) {
    ws.send(JSON.stringify(data));
  }
}

// ── Post-Session Summary Generator ─────────────────────────────

/**
 * Generates a structured post-session feedback report using the Gemini text API.
 * This is a separate, non-live API call that analyzes the accumulated transcript.
 */
export async function generatePostSessionSummary({ transcript, mode, stats }) {
  if (!ai) throw new Error('No Gemini auth configured');
  if (!transcript || transcript.length === 0) {
    return { summary: 'No transcript data available for analysis.', scores: null };
  }

  // Build transcript text from array of {role, text} entries
  let transcriptText = transcript
    .map((t) => `[${t.role.toUpperCase()}]: ${t.text}`)
    .join('\n');

  // Truncate very long transcripts to avoid hitting token limits
  const MAX_TRANSCRIPT_CHARS = 100000;
  if (transcriptText.length > MAX_TRANSCRIPT_CHARS) {
    const keepChars = Math.floor(MAX_TRANSCRIPT_CHARS * 0.45);
    transcriptText =
      transcriptText.slice(0, keepChars) +
      '\n\n[... middle portion omitted for brevity ...]\n\n' +
      transcriptText.slice(-keepChars);
    console.log(`[Summary] Transcript truncated from ${transcript.length} entries to fit token limits`);
  }

  const modeLabel = mode === 'interview' ? 'Behavioral Interview'
    : mode === 'presentation' || mode === 'present' ? 'Presentation / Public Speaking'
      : 'Startup Pitch';

  const prompt = `You are an expert communication coach analyzing a recorded coaching session. The session mode was: ${modeLabel}.

SESSION STATS:
- Duration: ${Math.floor(stats.durationSeconds / 60)}m ${stats.durationSeconds % 60}s
- AI coaching turns: ${stats.turns}
- Barge-in interruptions: ${stats.bargeIns}
- Video frames analyzed: ${stats.imagesSent}

FULL TRANSCRIPT:
${transcriptText}

Produce a structured feedback report in the following JSON format. Be brutally honest but constructive. Every score must be justified by specific moments from the transcript.

{
  "overallScore": <number 1-10>,
  "headline": "<one-sentence brutal verdict>",
  "strengths": ["<specific strength with transcript evidence>", ...],
  "weaknesses": ["<specific weakness with transcript evidence>", ...],
  "scores": {
    "content": { "score": <1-10>, "comment": "<brief>" },
    "delivery": { "score": <1-10>, "comment": "<brief>" },
    "bodyLanguage": { "score": <1-10>, "comment": "<brief>" },
    "structure": { "score": <1-10>, "comment": "<brief>" },
    "confidence": { "score": <1-10>, "comment": "<brief>" }
  },
  "keyMoments": [
    { "timestamp": "<approximate>", "observation": "<what happened>", "verdict": "good|bad|neutral" },
    ...
  ],
  "improvementPlan": [
    "<specific, actionable step 1>",
    "<specific, actionable step 2>",
    "<specific, actionable step 3>"
  ],
  "nextSessionFocus": "<what to drill next time>"
}

Return ONLY valid JSON, no markdown fences, no explanation.`;

  try {
    const textModel = process.env.GEMINI_TEXT_MODEL || TEXT_MODEL_NAME;
    console.log(`[Summary] Generating post-session report with model: ${textModel}`);

    const response = await ai.models.generateContent({
      model: textModel,
      contents: [{ role: 'user', parts: [{ text: prompt }] }],
    });

    const text = response.text?.trim() || response.candidates?.[0]?.content?.parts?.[0]?.text?.trim();
    if (!text) {
      console.error('[Summary] Empty response from Gemini text API');
      return { summary: 'Failed to generate summary — empty response.', scores: null };
    }

    // Parse JSON (strip markdown fences if present despite instruction)
    const cleaned = text.replace(/^```json?\s*/i, '').replace(/\s*```$/i, '').trim();
    const parsed = JSON.parse(cleaned);
    console.log(`[Summary] Report generated — overall score: ${parsed.overallScore}/10`);
    return { summary: parsed, scores: parsed.scores };
  } catch (err) {
    console.error('[Summary] Failed to generate report:', err.message);
    return { summary: `Summary generation failed: ${err.message}`, scores: null };
  }
}