interview updated

backend/routes/interview_api.py

@@ -16,40 +16,58 @@ interview_api = Blueprint("interview_api", __name__)
 @interview_api.route("/start_interview", methods=["POST"])
 @login_required
 def start_interview():
-    data = request.get_json()
+    """
+    Start a new interview. Generates the first question based on the user's
+    resume/profile and the selected job. Always returns a JSON payload
+    containing the question text and, if available, a URL to an audio
+    rendition of the question.
+
+    Previously this endpoint returned a raw audio file when TTS generation
+    succeeded. This prevented the client from displaying the actual question
+    and forced it to fall back to a hard‑coded default. By always returning
+    structured JSON we ensure the UI can show the generated question and
+    optionally play the associated audio.
+    """
+    data = request.get_json() or {}
     job_id = data.get("job_id")
-    
+
+    # Validate the job and the user's application
     job = Job.query.get_or_404(job_id)
     application = Application.query.filter_by(
-        user_id=current_user.id, 
+        user_id=current_user.id,
         job_id=job_id
     ).first()
-    
     if not application or not application.extracted_features:
         return jsonify({"error": "No application/profile data found."}), 400
-    
+
+    # Parse the candidate's profile
     try:
         profile = json.loads(application.extracted_features)
-    except:
+    except Exception:
         return jsonify({"error": "Invalid profile JSON"}), 500
-    
-    question = generate_first_question(profile, job)
-    
-    # Use /tmp directory which is writable in Hugging Face Spaces
-    audio_dir = "/tmp/audio"
-    os.makedirs(audio_dir, exist_ok=True)
 
-    audio_filename = f"q_{uuid.uuid4().hex}.wav"
-    audio_path = os.path.join(audio_dir, audio_filename)
+    # Generate the first question using the LLM
+    question = generate_first_question(profile, job)
 
-    # Generate audio synchronously. The function returns None on error.
-    audio_out = edge_tts_to_file_sync(question, audio_path)
+    # Attempt to generate a TTS audio file for the question. If successful
+    # we'll return a URL that the client can call to retrieve it; otherwise
+    # audio_url remains None.
+    audio_url = None
+    try:
+        audio_dir = "/tmp/audio"
+        os.makedirs(audio_dir, exist_ok=True)
+        filename = f"q_{uuid.uuid4().hex}.wav"
+        audio_path = os.path.join(audio_dir, filename)
+        audio_out = edge_tts_to_file_sync(question, audio_path)
+        if audio_out and os.path.exists(audio_path):
+            audio_url = url_for("interview_api.get_audio", filename=filename)
+    except Exception:
+        audio_url = None
 
-    if audio_out and os.path.exists(audio_path):
-        return send_file(audio_path, mimetype="audio/wav", as_attachment=False)
-    else:
-        # Fallback to JSON response if audio generation fails
-        return jsonify({"question": question})
+    return jsonify({
+        "question": question,
+        "audio_url": audio_url
+    })
 
 
 @interview_api.route("/transcribe_audio", methods=["POST"])
@@ -80,38 +98,63 @@ def transcribe_audio():
 @interview_api.route("/process_answer", methods=["POST"])
 @login_required
 def process_answer():
-    data = request.get_json()
+    """
+    Process a user's answer and return a follow‑up question along with an
+    evaluation. Always responds with JSON containing:
+
+      - success: boolean indicating the operation succeeded
+      - next_question: the text of the next question
+      - audio_url: optional URL to the TTS audio for the next question
+      - evaluation: a dict with a score and feedback
+      - is_complete: boolean indicating if the interview is finished
+
+    Returning JSON even when audio generation succeeds simplifies client
+    handling and prevents errors when parsing the response.
+    """
+    data = request.get_json() or {}
     answer = data.get("answer", "")
     question_idx = data.get("questionIndex", 0)
-    
-    # Generate next question (simplified for now). In a full implementation this
-    # would call a model such as groq_llm to generate a follow‑up question based
-    # on the candidate's answer.
-    next_question = f"Follow‑up question {question_idx + 2}: Can you elaborate on your experience with relevant technologies?"
-
-    # Use /tmp directory for audio files
-    audio_dir = "/tmp/audio"
-    os.makedirs(audio_dir, exist_ok=True)
-
-    audio_filename = f"q_{uuid.uuid4().hex}.wav"
-    audio_path = os.path.join(audio_dir, audio_filename)
-
-    # Attempt to generate speech for the next question. If audio generation
-    # fails, ``audio_out`` will be None and we return JSON response instead.
-    audio_out = edge_tts_to_file_sync(next_question, audio_path)
-
-    if audio_out and os.path.exists(audio_path):
-        return send_file(audio_path, mimetype="audio/wav", as_attachment=False)
-    else:
-        # Fallback to JSON response
-        response = {
-            "success": True,
-            "nextQuestion": next_question,
-            "evaluation": {
-                "score": "medium",
-                "feedback": "Good answer, but be more specific."
-            },
-            "isComplete": question_idx >= 2,
-            "summary": []
-        }
-        return jsonify(response)
+
+    # Construct the next question. In a full implementation this would
+    # depend on the user's answer and job description.
+    next_question_text = f"Follow‑up question {question_idx + 2}: Can you elaborate on your experience with relevant technologies?"
+
+    # Stubbed evaluation of the answer. Replace with a call to evaluate_answer()
+    evaluation_result = {
+        "score": "medium",
+        "feedback": "Good answer, but be more specific."
+    }
+
+    # Determine completion (3 questions in total, zero‑based index)
+    is_complete = question_idx >= 2
+
+    # Try to generate audio for the next question
+    audio_url = None
+    try:
+        audio_dir = "/tmp/audio"
+        os.makedirs(audio_dir, exist_ok=True)
+        filename = f"q_{uuid.uuid4().hex}.wav"
+        audio_path = os.path.join(audio_dir, filename)
+        audio_out = edge_tts_to_file_sync(next_question_text, audio_path)
+        if audio_out and os.path.exists(audio_path):
+            audio_url = url_for("interview_api.get_audio", filename=filename)
+    except Exception:
+        audio_url = None
+
+    return jsonify({
+        "success": True,
+        "next_question": next_question_text,
+        "audio_url": audio_url,
+        "evaluation": evaluation_result,
+        "is_complete": is_complete
+    })
+
+@interview_api.route("/audio/<string:filename>", methods=["GET"])
+@login_required
+def get_audio(filename: str):
+    """Serve previously generated TTS audio from the /tmp/audio directory."""
+    safe_name = os.path.basename(filename)
+    audio_path = os.path.join("/tmp/audio", safe_name)
+    if not os.path.exists(audio_path):
+        return jsonify({"error": "Audio file not found."}), 404
+    return send_file(audio_path, mimetype="audio/wav", as_attachment=False)

backend/services/interview_engine.py

@@ -1,4 +1,3 @@
-# Updated `interview_engine.py`
 import os
 import json
 import asyncio
@@ -7,116 +6,147 @@ from faster_whisper import WhisperModel
 from langchain_groq import ChatGroq
 import logging
 
-# ------------------
-# Model Initialization (done once)
-# ------------------
+# Initialize models
+chat_groq_api = os.getenv("GROQ_API_KEY")
+if not chat_groq_api:
+    raise ValueError("GROQ_API_KEY is not set in environment variables.")
 groq_llm = ChatGroq(
     temperature=0.7,
-    model_name="llama-3-3-70b-versatile",
-    api_key=os.getenv("GROQ_API_KEY")
+    model_name="llama-3.3-70b-versatile",
+    api_key=chat_groq_api
 )
 
+# Initialize Whisper model
 whisper_model = None
 
-# ------------------
-# Load Whisper lazily
-# ------------------
 def load_whisper_model():
     global whisper_model
     if whisper_model is None:
-        device = "cuda" if os.system("nvidia-smi > /dev/null 2>&1") == 0 else "cpu"
+        device = "cuda" if os.system("nvidia-smi") == 0 else "cpu"
         compute_type = "float16" if device == "cuda" else "int8"
         whisper_model = WhisperModel("base", device=device, compute_type=compute_type)
     return whisper_model
 
-# ------------------
-# Generate Question
-# ------------------
 def generate_first_question(profile, job):
-    prompt = f"""
-    You are conducting an interview for a {job.role} position at {job.company}.
-    The candidate's profile shows:
-    - Skills: {profile.get('skills', [])}
-    - Experience: {profile.get('experience', [])}
-    - Education: {profile.get('education', [])}
-
-    Generate an appropriate opening interview question that is professional and relevant.
-    Keep it concise and clear.
-    """
+    """Generate the first interview question based on profile and job"""
     try:
-        response = groq_llm.invoke(prompt)
+        prompt = f"""
+        You are conducting an interview for a {job.role} position at {job.company}.
+        The candidate's profile shows:
+        - Skills: {profile.get('skills', [])}
+        - Experience: {profile.get('experience', [])}
+        - Education: {profile.get('education', [])}
+        
+        Generate an appropriate opening interview question that is professional and relevant.
+        Keep it concise and clear.
+        """
+        
+        response = groq_llm.predict(prompt)
         return response.strip()
     except Exception as e:
-        logging.error(f"Question generation failed: {e}")
+        logging.error(f"Error generating first question: {e}")
         return "Tell me about yourself and why you're interested in this position."
 
-# ------------------
-# TTS (Edge)
-# ------------------
 def edge_tts_to_file_sync(text, output_path, voice="en-US-AriaNeural"):
+    """Synchronous wrapper for edge-tts"""
     try:
-        directory = os.path.dirname(output_path) or "/tmp"
+        # Ensure the directory exists and is writable
+        directory = os.path.dirname(output_path)
+        if not directory:
+            directory = "/tmp"  # Fallback to /tmp if no directory specified
+            output_path = os.path.join(directory, os.path.basename(output_path))
+        
         os.makedirs(directory, exist_ok=True)
-
-        async def generate():
+        
+        # Test write permissions
+        test_file = os.path.join(directory, f"test_{os.getpid()}.tmp")
+        try:
+            with open(test_file, 'w') as f:
+                f.write("test")
+            os.remove(test_file)
+        except (PermissionError, OSError) as e:
+            logging.error(f"Directory {directory} is not writable: {e}")
+            # Fallback to /tmp
+            directory = "/tmp"
+            output_path = os.path.join(directory, os.path.basename(output_path))
+            os.makedirs(directory, exist_ok=True)
+        
+        async def generate_audio():
             communicate = edge_tts.Communicate(text, voice)
             await communicate.save(output_path)
-
-        loop = asyncio.get_event_loop()
-        if loop.is_running():
-            import nest_asyncio
-            nest_asyncio.apply()
+        
+        # Run async function in sync context
+        try:
             loop = asyncio.get_event_loop()
-        loop.run_until_complete(generate())
-
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+        
+        loop.run_until_complete(generate_audio())
+        
+        # Verify file was created and has content
         if os.path.exists(output_path) and os.path.getsize(output_path) > 0:
             return output_path
+        else:
+            logging.error(f"Audio file was not created or is empty: {output_path}")
+            return None
+            
     except Exception as e:
-        logging.error(f"TTS generation failed: {e}")
-    return None
+        logging.error(f"Error in TTS generation: {e}")
+        return None
 
-# ------------------
-# Transcription
-# ------------------
 def whisper_stt(audio_path):
-    if not audio_path or not os.path.exists(audio_path):
-        return ""
+    """Speech-to-text using Faster-Whisper"""
     try:
+        if not audio_path or not os.path.exists(audio_path):
+            logging.error(f"Audio file does not exist: {audio_path}")
+            return ""
+        
+        # Check if file has content
+        if os.path.getsize(audio_path) == 0:
+            logging.error(f"Audio file is empty: {audio_path}")
+            return ""
+        
         model = load_whisper_model()
         segments, _ = model.transcribe(audio_path)
-        return " ".join(segment.text for segment in segments).strip()
+        transcript = " ".join(segment.text for segment in segments)
+        return transcript.strip()
     except Exception as e:
-        logging.error(f"STT failed: {e}")
+        logging.error(f"Error in STT: {e}")
         return ""
 
-# ------------------
-# Answer Evaluation
-# ------------------
 def evaluate_answer(question, answer, ref_answer, job_role, seniority):
-    prompt = f"""
-    You are evaluating a candidate's answer for a {seniority} {job_role} position.
-
-    Question: {question}
-    Candidate Answer: {answer}
-    Reference Answer: {ref_answer}
-
-    Evaluate based on technical correctness, clarity, and relevance.
-    Respond with JSON format:
-    {{
-        "Score": "Poor|Medium|Good|Excellent",
-        "Reasoning": "brief explanation",
-        "Improvements": ["suggestion1", "suggestion2"]
-    }}
-    """
+    """Evaluate candidate's answer"""
     try:
-        response = groq_llm.invoke(prompt)
-        start = response.find("{")
-        end = response.rfind("}") + 1
-        return json.loads(response[start:end]) if start >= 0 else {}
+        prompt = f"""
+        You are evaluating a candidate's answer for a {seniority} {job_role} position.
+        
+        Question: {question}
+        Candidate Answer: {answer}
+        Reference Answer: {ref_answer}
+        
+        Evaluate based on technical correctness, clarity, and relevance.
+        Respond with JSON format:
+        {{
+            "Score": "Poor|Medium|Good|Excellent",
+            "Reasoning": "brief explanation",
+            "Improvements": ["suggestion1", "suggestion2"]
+        }}
+        """
+        
+        response = groq_llm.predict(prompt)
+        # Extract JSON from response
+        start_idx = response.find("{")
+        end_idx = response.rfind("}") + 1
+        if start_idx >= 0 and end_idx > start_idx:
+            json_str = response[start_idx:end_idx]
+            return json.loads(json_str)
+        else:
+            raise ValueError("No valid JSON found in response")
     except Exception as e:
-        logging.error(f"Evaluation failed: {e}")
+        logging.error(f"Error evaluating answer: {e}")
         return {
             "Score": "Medium",
             "Reasoning": "Evaluation failed",
-            "Improvements": ["Be more specific"]
-        }
+            "Improvements": ["Please be more specific"]
+        }

backend/templates/interview.html

@@ -577,25 +577,16 @@
                         throw new Error(`HTTP error! status: ${response.status}`);
                     }
 
-                    const contentType = response.headers.get("Content-Type");
-                    if (contentType.includes("audio")) {
-                        const audioBlob = await response.blob();
-                        const audioUrl = URL.createObjectURL(audioBlob);
-
-                        const fallbackText = "Let's begin. Can you introduce yourself?";
-                        this.displayQuestion(fallbackText, audioUrl);
-                        this.interviewData.questions.push(fallbackText);
-                    } else {
-                        const data = await response.json();
-                        if (data.error) {
-                            this.showError(data.error);
-                            return;
-                        }
-
-                        this.displayQuestion(data.question, data.audio_url);
-                        this.interviewData.questions.push(data.question);
+                    // Always expect a JSON payload describing the question and optional audio URL
+                    const data = await response.json();
+                    if (data.error) {
+                        this.showError(data.error);
+                        return;
                     }
 
+                    // Display the actual question text and play audio if provided
+                    this.displayQuestion(data.question, data.audio_url);
+                    this.interviewData.questions.push(data.question);
                 } catch (error) {
                     console.error('Error starting interview:', error);
                     this.showError('Failed to start interview. Please try again.');
@@ -766,51 +757,27 @@
                         throw new Error(`HTTP error! status: ${response.status}`);
                     }
 
-                    const contentType = response.headers.get("Content-Type");
-                    if (contentType.includes("audio")) {
-                        const audioBlob = await response.blob();
-                        const audioUrl = URL.createObjectURL(audioBlob);
-
-                        const fallback = `Follow-up question ${this.currentQuestionIndex + 2}: Can you elaborate more?`;
-                        this.interviewData.answers.push(answer);
-                        this.interviewData.evaluations.push({
-                            score: "N/A",
-                            feedback: "No feedback available in fallback mode."
-                        });
-
-                        if (this.currentQuestionIndex >= 2) {
-                            this.showInterviewSummary();
-                        } else {
-                            this.currentQuestionIndex++;
-                            this.displayQuestion(fallback, audioUrl);
-                            this.interviewData.questions.push(fallback);
-                            this.resetForNextQuestion();
-                        }
-                    } else {
-                        const data = await response.json();
-                        if (data.success) {
-                            this.interviewData.answers.push(answer);
-                            this.interviewData.evaluations.push(data.evaluation);
-
-                            if (data.isComplete) {
-                                this.showInterviewSummary();
-                            } else {
-                                this.currentQuestionIndex++;
-                                this.displayQuestion(data.nextQuestion, data.audioUrl);
-                                this.interviewData.questions.push(data.nextQuestion);
-                                this.resetForNextQuestion();
-                            }
-                        } else {
-                            this.showError('Failed to process answer. Please try again.');
-                        }
-                    }
-
-                    
-                    if (data.error) {
-                        this.showError(data.error);
+                    // Parse JSON response
+                    const data = await response.json();
+                    if (!data.success) {
+                        this.showError('Failed to process answer. Please try again.');
                         return;
                     }
 
+                    // Record the user's answer and its evaluation
+                    this.interviewData.answers.push(answer);
+                    this.interviewData.evaluations.push(data.evaluation || {});
+
+                    if (data.is_complete) {
+                        // Interview finished, show summary
+                        this.showInterviewSummary();
+                    } else {
+                        // Advance to next question
+                        this.currentQuestionIndex++;
+                        this.displayQuestion(data.next_question, data.audio_url);
+                        this.interviewData.questions.push(data.next_question);
+                        this.resetForNextQuestion();
+                    }
                 } catch (error) {
                     console.error('Error submitting answer:', error);
                     this.showError('Connection error. Please try again.');