full new update

Dockerfile

@@ -2,8 +2,8 @@ FROM python:3.10-slim
 
 # Install OS dependencies
 RUN apt-get update && apt-get install -y \
-    ffmpeg libsndfile1 libgl1 git curl \
-    build-essential && \
+    ffmpeg libsndfile1 libsndfile1-dev libgl1 git curl \
+    build-essential pkg-config && \
     rm -rf /var/lib/apt/lists/*
 
 # Set working directory
@@ -19,8 +19,9 @@ RUN pip install -r requirements.txt
 # Copy everything to the container
 COPY . .
 
-# Create necessary directories
-RUN mkdir -p static/audio temp backend/instance uploads/resumes data/resumes
+# Create necessary directories with proper permissions
+RUN mkdir -p static/audio temp backend/instance uploads/resumes data/resumes /tmp/audio /tmp/interview_temp && \
+    chmod 777 /tmp/audio /tmp/interview_temp
 
 # Expose port
 EXPOSE 7860

backend/routes/interview_api.py

@@ -1,6 +1,7 @@
 import os
 import uuid
 import json
+import logging
 from flask import Blueprint, request, jsonify, send_file, url_for, current_app
 from flask_login import login_required, current_user
 from backend.models.database import db, Job, Application
@@ -21,140 +22,210 @@ def start_interview():
     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,
-        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 Exception:
-        return jsonify({"error": "Invalid profile JSON"}), 500
-
-    # Generate the first question using the LLM
-    question = generate_first_question(profile, job)
-
-    # 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:
+        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,
+            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 Exception as e:
+            logging.error(f"Invalid profile JSON: {e}")
+            return jsonify({"error": "Invalid profile JSON"}), 500
+
+        # Generate the first question using the LLM
+        question = generate_first_question(profile, job)
+        
+        if not question:
+            question = "Tell me about yourself and why you're interested in this position."
+
+        # Attempt to generate a TTS audio file for the question
         audio_url = None
-
-    return jsonify({
-        "question": question,
-        "audio_url": audio_url
-    })
+        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_result = edge_tts_to_file_sync(question, audio_path)
+            if audio_result and os.path.exists(audio_path) and os.path.getsize(audio_path) > 1000:
+                audio_url = url_for("interview_api.get_audio", filename=filename)
+                logging.info(f"Audio generated successfully: {audio_url}")
+            else:
+                logging.warning("Audio generation failed or file too small")
+        except Exception as e:
+            logging.error(f"Error generating TTS audio: {e}")
+            audio_url = None
+
+        return jsonify({
+            "question": question,
+            "audio_url": audio_url
+        })
+        
+    except Exception as e:
+        logging.error(f"Error in start_interview: {e}")
+        return jsonify({"error": "Internal server error"}), 500
 
 
 @interview_api.route("/transcribe_audio", methods=["POST"])
 @login_required
 def transcribe_audio():
-    audio_file = request.files.get("audio")
-    if not audio_file:
-        return jsonify({"error": "No audio file received."}), 400
-    
-    # Use /tmp directory which is writable in Hugging Face Spaces
-    temp_dir = "/tmp/interview_temp"
-    os.makedirs(temp_dir, exist_ok=True)
-
-    filename = f"user_audio_{uuid.uuid4().hex}.webm"
-    path = os.path.join(temp_dir, filename)
-    audio_file.save(path)
-    
-    transcript = whisper_stt(path)
-    
-    # Clean up
+    """Transcribe uploaded audio with better error handling"""
     try:
-        os.remove(path)
-    except:
-        pass
-    
-    return jsonify({"transcript": transcript})
+        audio_file = request.files.get("audio")
+        if not audio_file:
+            return jsonify({"error": "No audio file received."}), 400
+        
+        # Check if file has content
+        audio_file.seek(0, 2)  # Seek to end
+        file_size = audio_file.tell()
+        audio_file.seek(0)  # Seek back to start
+        
+        if file_size == 0:
+            logging.error("Received empty audio file")
+            return jsonify({"error": "Empty audio file received."}), 400
+        
+        logging.info(f"Received audio file: {file_size} bytes")
+        
+        # Use /tmp directory which is writable in Hugging Face Spaces
+        temp_dir = "/tmp/interview_temp"
+        os.makedirs(temp_dir, exist_ok=True)
+
+        # Keep original extension for better compatibility
+        original_filename = audio_file.filename or "recording.webm"
+        file_extension = os.path.splitext(original_filename)[1] or ".webm"
+        filename = f"user_audio_{uuid.uuid4().hex}{file_extension}"
+        path = os.path.join(temp_dir, filename)
+        
+        # Save the file
+        audio_file.save(path)
+        
+        # Verify file was saved
+        if not os.path.exists(path) or os.path.getsize(path) == 0:
+            logging.error(f"Failed to save audio file or file is empty: {path}")
+            return jsonify({"error": "Failed to save audio file."}), 500
+        
+        logging.info(f"Audio file saved: {path} ({os.path.getsize(path)} bytes)")
+        
+        # Transcribe the audio
+        transcript = whisper_stt(path)
+        
+        # Clean up
+        try:
+            os.remove(path)
+        except Exception as e:
+            logging.warning(f"Could not remove temp file {path}: {e}")
+        
+        if not transcript or not transcript.strip():
+            return jsonify({"error": "No speech detected in audio. Please try again."}), 400
+        
+        return jsonify({"transcript": transcript})
+        
+    except Exception as e:
+        logging.error(f"Error in transcribe_audio: {e}")
+        return jsonify({"error": "Error processing audio. Please try again."}), 500
 
 @interview_api.route("/process_answer", methods=["POST"])
 @login_required
 def process_answer():
     """
     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.
+    evaluation. Always responds with JSON.
     """
-    data = request.get_json() or {}
-    answer = data.get("answer", "")
-    question_idx = data.get("questionIndex", 0)
-
-    # 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:
+        data = request.get_json() or {}
+        answer = data.get("answer", "").strip()
+        question_idx = data.get("questionIndex", 0)
+        
+        if not answer:
+            return jsonify({"error": "No answer provided."}), 400
+
+        # Get the current question for evaluation context
+        current_question = data.get("current_question", "Tell me about yourself")
+
+        # Evaluate the answer
+        evaluation_result = evaluate_answer(current_question, answer)
+
+        # Determine completion (3 questions in total, zero‑based index)
+        is_complete = question_idx >= 2
+        
+        next_question_text = None
         audio_url = None
-
-    return jsonify({
-        "success": True,
-        "next_question": next_question_text,
-        "audio_url": audio_url,
-        "evaluation": evaluation_result,
-        "is_complete": is_complete
-    })
+        
+        if not is_complete:
+            # Generate next question based on question index
+            if question_idx == 0:
+                next_question_text = "Can you describe a challenging project you've worked on and how you overcame the difficulties?"
+            elif question_idx == 1:
+                next_question_text = "What are your career goals and how does this position align with them?"
+            else:
+                next_question_text = "Do you have any questions about the role or our company?"
+
+            # Try to generate audio for the next question
+            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_result = edge_tts_to_file_sync(next_question_text, audio_path)
+                if audio_result and os.path.exists(audio_path) and os.path.getsize(audio_path) > 1000:
+                    audio_url = url_for("interview_api.get_audio", filename=filename)
+                    logging.info(f"Next question audio generated: {audio_url}")
+            except Exception as e:
+                logging.error(f"Error generating next question audio: {e}")
+                audio_url = None
+
+        return jsonify({
+            "success": True,
+            "next_question": next_question_text,
+            "audio_url": audio_url,
+            "evaluation": evaluation_result,
+            "is_complete": is_complete
+        })
+        
+    except Exception as e:
+        logging.error(f"Error in process_answer: {e}")
+        return jsonify({"error": "Error processing answer. Please try again."}), 500
 
 @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)
+    try:
+        # Sanitize filename to prevent directory traversal
+        safe_name = os.path.basename(filename)
+        if not safe_name.endswith('.wav'):
+            return jsonify({"error": "Invalid audio file format."}), 400
+            
+        audio_path = os.path.join("/tmp/audio", safe_name)
+        
+        if not os.path.exists(audio_path):
+            logging.warning(f"Audio file not found: {audio_path}")
+            return jsonify({"error": "Audio file not found."}), 404
+            
+        if os.path.getsize(audio_path) == 0:
+            logging.warning(f"Audio file is empty: {audio_path}")
+            return jsonify({"error": "Audio file is empty."}), 404
+            
+        return send_file(
+            audio_path, 
+            mimetype="audio/wav", 
+            as_attachment=False,
+            conditional=True  # Enable range requests for better audio streaming
+        )
+        
+    except Exception as e:
+        logging.error(f"Error serving audio file {filename}: {e}")
+        return jsonify({"error": "Error serving audio file."}), 500

backend/services/interview_engine.py

@@ -5,6 +5,8 @@ import edge_tts
 from faster_whisper import WhisperModel
 from langchain_groq import ChatGroq
 import logging
+import tempfile
+import shutil
 
 # Initialize models
 chat_groq_api = os.getenv("GROQ_API_KEY")
@@ -22,9 +24,15 @@ whisper_model = None
 def load_whisper_model():
     global whisper_model
     if whisper_model is None:
-        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)
+        try:
+            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)
+            logging.info(f"Whisper model loaded on {device} with {compute_type}")
+        except Exception as e:
+            logging.error(f"Error loading Whisper model: {e}")
+            # Fallback to CPU
+            whisper_model = WhisperModel("base", device="cpu", compute_type="int8")
     return whisper_model
 
 def generate_first_question(profile, job):
@@ -38,115 +46,252 @@ def generate_first_question(profile, job):
         - Education: {profile.get('education', [])}
         
         Generate an appropriate opening interview question that is professional and relevant.
-        Keep it concise and clear.
+        Keep it concise and clear. Respond with ONLY the question text, no additional formatting.
         """
         
         response = groq_llm.invoke(prompt)
-        return response.content.strip()
+        
+        # Fix: Handle AIMessage object properly
+        if hasattr(response, 'content'):
+            question = response.content.strip()
+        elif isinstance(response, str):
+            question = response.strip()
+        else:
+            question = str(response).strip()
+            
+        # Ensure we have a valid question
+        if not question or len(question) < 10:
+            question = "Tell me about yourself and why you're interested in this position."
+            
+        logging.info(f"Generated question: {question}")
+        return question
+        
     except Exception as e:
         logging.error(f"Error generating first question: {e}")
         return "Tell me about yourself and why you're interested in this position."
 
 def edge_tts_to_file_sync(text, output_path, voice="en-US-AriaNeural"):
-    """Synchronous wrapper for edge-tts"""
+    """Synchronous wrapper for edge-tts with better error handling"""
     try:
+        # Ensure text is not empty
+        if not text or not text.strip():
+            logging.error("Empty text provided for TTS")
+            return None
+            
         # 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
+            directory = "/tmp/audio"
             output_path = os.path.join(directory, os.path.basename(output_path))
         
         os.makedirs(directory, exist_ok=True)
         
-        # Test write permissions
+        # Test write permissions with a temporary file
         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)
+            logging.info(f"Directory {directory} is writable")
         except (PermissionError, OSError) as e:
             logging.error(f"Directory {directory} is not writable: {e}")
             # Fallback to /tmp
-            directory = "/tmp"
+            directory = "/tmp/audio"
             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)
+            try:
+                communicate = edge_tts.Communicate(text, voice)
+                await communicate.save(output_path)
+                logging.info(f"TTS audio saved to: {output_path}")
+            except Exception as e:
+                logging.error(f"Error in async TTS generation: {e}")
+                raise
         
         # Run async function in sync context
         try:
             loop = asyncio.get_event_loop()
+            if loop.is_running():
+                # If loop is already running, create a new one in a thread
+                import threading
+                import concurrent.futures
+                
+                def run_in_thread():
+                    new_loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(new_loop)
+                    try:
+                        new_loop.run_until_complete(generate_audio())
+                    finally:
+                        new_loop.close()
+                
+                with concurrent.futures.ThreadPoolExecutor() as executor:
+                    future = executor.submit(run_in_thread)
+                    future.result(timeout=30)  # 30 second timeout
+            else:
+                loop.run_until_complete(generate_audio())
         except RuntimeError:
+            # No event loop exists
             loop = asyncio.new_event_loop()
             asyncio.set_event_loop(loop)
-        
-        loop.run_until_complete(generate_audio())
+            try:
+                loop.run_until_complete(generate_audio())
+            finally:
+                loop.close()
         
         # Verify file was created and has content
-        if os.path.exists(output_path) and os.path.getsize(output_path) > 0:
-            return output_path
+        if os.path.exists(output_path):
+            file_size = os.path.getsize(output_path)
+            if file_size > 1000:  # At least 1KB for a valid audio file
+                logging.info(f"TTS file created successfully: {output_path} ({file_size} bytes)")
+                return output_path
+            else:
+                logging.error(f"TTS file is too small: {output_path} ({file_size} bytes)")
+                return None
         else:
-            logging.error(f"Audio file was not created or is empty: {output_path}")
+            logging.error(f"TTS file was not created: {output_path}")
             return None
             
     except Exception as e:
         logging.error(f"Error in TTS generation: {e}")
         return None
 
+def convert_webm_to_wav(webm_path, wav_path):
+    """Convert WebM audio to WAV using ffmpeg if available"""
+    try:
+        import subprocess
+        result = subprocess.run([
+            'ffmpeg', '-i', webm_path, '-ar', '16000', '-ac', '1', '-y', wav_path
+        ], capture_output=True, text=True, timeout=30)
+        
+        if result.returncode == 0 and os.path.exists(wav_path) and os.path.getsize(wav_path) > 0:
+            logging.info(f"Successfully converted {webm_path} to {wav_path}")
+            return wav_path
+        else:
+            logging.error(f"FFmpeg conversion failed: {result.stderr}")
+            return None
+    except (subprocess.TimeoutExpired, FileNotFoundError, Exception) as e:
+        logging.error(f"Error converting audio: {e}")
+        return None
+
 def whisper_stt(audio_path):
-    """Speech-to-text using Faster-Whisper"""
+    """Speech-to-text using Faster-Whisper with better error handling"""
     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:
+        file_size = os.path.getsize(audio_path)
+        if file_size == 0:
             logging.error(f"Audio file is empty: {audio_path}")
             return ""
         
+        logging.info(f"Processing audio file: {audio_path} ({file_size} bytes)")
+        
+        # If the file is WebM, try to convert it to WAV
+        if audio_path.endswith('.webm'):
+            wav_path = audio_path.replace('.webm', '.wav')
+            converted_path = convert_webm_to_wav(audio_path, wav_path)
+            if converted_path:
+                audio_path = converted_path
+            else:
+                logging.warning("Could not convert WebM to WAV, trying with original file")
+        
         model = load_whisper_model()
-        segments, _ = model.transcribe(audio_path)
-        transcript = " ".join(segment.text for segment in segments)
-        return transcript.strip()
+        
+        # Add timeout and better error handling
+        try:
+            segments, info = model.transcribe(
+                audio_path,
+                language="en",  # Specify language for better performance
+                task="transcribe",
+                vad_filter=True,  # Voice activity detection
+                vad_parameters=dict(min_silence_duration_ms=500)
+            )
+            
+            transcript_parts = []
+            for segment in segments:
+                if hasattr(segment, 'text') and segment.text.strip():
+                    transcript_parts.append(segment.text.strip())
+            
+            transcript = " ".join(transcript_parts)
+            
+            if transcript:
+                logging.info(f"Transcription successful: '{transcript[:100]}...'")
+            else:
+                logging.warning("No speech detected in audio file")
+                
+            return transcript.strip()
+            
+        except Exception as e:
+            logging.error(f"Error during transcription: {e}")
+            return ""
+        
     except Exception as e:
         logging.error(f"Error in STT: {e}")
         return ""
 
-def evaluate_answer(question, answer, ref_answer, job_role, seniority):
-    """Evaluate candidate's answer"""
+def evaluate_answer(question, answer, job_role="Software Developer", seniority="Mid-level"):
+    """Evaluate candidate's answer with better error handling"""
     try:
+        if not answer or not answer.strip():
+            return {
+                "score": "Poor",
+                "feedback": "No answer provided."
+            }
+            
         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"]
-        }}
+        Provide a brief evaluation in 1-2 sentences.
+        
+        Rate the answer as one of: Poor, Medium, Good, Excellent
+        
+        Respond in this exact format:
+        Score: [Poor/Medium/Good/Excellent]
+        Feedback: [Your brief feedback here]
         """
         
         response = groq_llm.invoke(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)
+        
+        # Handle AIMessage object properly
+        if hasattr(response, 'content'):
+            response_text = response.content.strip()
+        elif isinstance(response, str):
+            response_text = response.strip()
         else:
-            raise ValueError("No valid JSON found in response")
+            response_text = str(response).strip()
+        
+        # Parse the response
+        lines = response_text.split('\n')
+        score = "Medium"  # default
+        feedback = "Good answer, but could be more detailed."  # default
+        
+        for line in lines:
+            line = line.strip()
+            if line.startswith('Score:'):
+                score = line.replace('Score:', '').strip()
+            elif line.startswith('Feedback:'):
+                feedback = line.replace('Feedback:', '').strip()
+        
+        # Ensure score is valid
+        valid_scores = ["Poor", "Medium", "Good", "Excellent"]
+        if score not in valid_scores:
+            score = "Medium"
+        
+        return {
+            "score": score,
+            "feedback": feedback
+        }
+        
     except Exception as e:
         logging.error(f"Error evaluating answer: {e}")
         return {
-            "Score": "Medium",
-            "Reasoning": "Evaluation failed",
-            "Improvements": ["Please be more specific"]
+            "score": "Medium",
+            "feedback": "Unable to evaluate answer at this time."
         }

backend/templates/interview.html

@@ -498,6 +498,7 @@
                 this.isRecording = false;
                 this.mediaRecorder = null;
                 this.audioChunks = [];
+                this.currentQuestion = "";
                 this.interviewData = {
                     questions: [],
                     answers: [],
@@ -525,10 +526,23 @@
             }
 
             bindEvents() {
-                this.micButton.addEventListener('mousedown', () => this.startRecording());
-                this.micButton.addEventListener('mouseup', () => this.stopRecording());
-                this.micButton.addEventListener('mouseleave', () => this.stopRecording());
+                // Mouse events for desktop
+                this.micButton.addEventListener('mousedown', (e) => {
+                    e.preventDefault();
+                    this.startRecording();
+                });
+
+                this.micButton.addEventListener('mouseup', (e) => {
+                    e.preventDefault();
+                    this.stopRecording();
+                });
+
+                this.micButton.addEventListener('mouseleave', (e) => {
+                    e.preventDefault();
+                    this.stopRecording();
+                });
 
+                // Touch events for mobile
                 this.micButton.addEventListener('touchstart', (e) => {
                     e.preventDefault();
                     this.startRecording();
@@ -565,6 +579,7 @@
 
             async initializeInterview() {
                 try {
+                    console.log('Starting interview...');
                     const response = await fetch('/api/start_interview', {
                         method: 'POST',
                         headers: {
@@ -574,26 +589,29 @@
                     });
 
                     if (!response.ok) {
+                        const errorText = await response.text();
+                        console.error('Server response:', response.status, errorText);
                         throw new Error(`HTTP error! status: ${response.status}`);
                     }
 
-                    // Always expect a JSON payload describing the question and optional audio URL
                     const data = await response.json();
+                    console.log('Received interview data:', data);
+
                     if (data.error) {
                         this.showError(data.error);
                         return;
                     }
 
-                    // Display the actual question text and play audio if provided
+                    // Store the current question for evaluation
+                    this.currentQuestion = data.question;
                     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.');
+                    this.showError('Failed to start interview. Please check your connection and try again.');
                 }
             }
 
-
             displayQuestion(question, audioUrl = null) {
                 // Remove loading message
                 const loadingMsg = document.getElementById('loadingMessage');
@@ -605,11 +623,11 @@
                 const messageDiv = document.createElement('div');
                 messageDiv.className = 'ai-message';
                 messageDiv.innerHTML = `
-                    <div class="ai-avatar talking">AI</div>
-                    <div class="message-bubble">
-                        <p>${question}</p>
-                    </div>
-                `;
+            <div class="ai-avatar">AI</div>
+            <div class="message-bubble">
+                <p>${question}</p>
+            </div>
+        `;
                 this.chatArea.appendChild(messageDiv);
                 this.chatArea.scrollTop = this.chatArea.scrollHeight;
 
@@ -618,17 +636,25 @@
 
                 // Play audio if available
                 if (audioUrl) {
+                    console.log('Playing audio:', audioUrl);
                     this.playQuestionAudio(audioUrl);
                 } else {
-                    // Enable controls if no audio
+                    console.log('No audio URL provided, enabling controls');
                     setTimeout(() => this.enableControls(), 1000);
                 }
             }
 
             playQuestionAudio(audioUrl) {
+                // Add talking animation immediately
+                const avatars = this.chatArea.querySelectorAll('.ai-avatar');
+                avatars.forEach(avatar => avatar.classList.add('talking'));
+
                 this.ttsAudio.src = audioUrl;
+                this.ttsAudio.load(); // Ensure audio is loaded
+
                 this.ttsAudio.play().catch(error => {
                     console.error('Audio play error:', error);
+                    avatars.forEach(avatar => avatar.classList.remove('talking'));
                     this.enableControls();
                 });
             }
@@ -637,31 +663,61 @@
                 this.micButton.disabled = false;
                 this.recordingStatus.textContent = 'Click and hold to record your answer';
 
-                // Remove talking animation from avatar
+                // Remove talking animation from all avatars
                 const avatars = this.chatArea.querySelectorAll('.ai-avatar');
                 avatars.forEach(avatar => avatar.classList.remove('talking'));
             }
 
             async startRecording() {
-                if (this.isRecording) return;
+                if (this.isRecording || this.micButton.disabled) return;
 
                 try {
-                    const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
-                    this.mediaRecorder = new MediaRecorder(stream, {
-                     mimeType: 'audio/webm;codecs=opus'
+                    console.log('Starting recording...');
+                    const stream = await navigator.mediaDevices.getUserMedia({
+                        audio: {
+                            echoCancellation: true,
+                            noiseSuppression: true,
+                            autoGainControl: true,
+                            sampleRate: 16000
+                        }
                     });
+
+                    // Use webm format with opus codec for better compatibility
+                    const options = {
+                        mimeType: 'audio/webm;codecs=opus'
+                    };
+
+                    // Fallback for browsers that don't support webm
+                    if (!MediaRecorder.isTypeSupported(options.mimeType)) {
+                        options.mimeType = 'audio/webm';
+                    }
+                    if (!MediaRecorder.isTypeSupported(options.mimeType)) {
+                        delete options.mimeType;
+                    }
+
+                    this.mediaRecorder = new MediaRecorder(stream, options);
                     this.audioChunks = [];
 
                     this.mediaRecorder.ondataavailable = (event) => {
-                        this.audioChunks.push(event.data);
+                        if (event.data.size > 0) {
+                            this.audioChunks.push(event.data);
+                            console.log('Audio chunk received:', event.data.size, 'bytes');
+                        }
                     };
 
                     this.mediaRecorder.onstop = () => {
+                        console.log('Recording stopped, processing...');
+                        stream.getTracks().forEach(track => track.stop());
                         this.processRecording();
+                    };
+
+                    this.mediaRecorder.onerror = (event) => {
+                        console.error('MediaRecorder error:', event.error);
+                        this.recordingStatus.textContent = 'Recording error. Please try again.';
                         stream.getTracks().forEach(track => track.stop());
                     };
 
-                    this.mediaRecorder.start();
+                    this.mediaRecorder.start(1000); // Collect data every second
                     this.isRecording = true;
 
                     // Update UI
@@ -672,12 +728,14 @@
                 } catch (error) {
                     console.error('Error starting recording:', error);
                     this.recordingStatus.textContent = 'Microphone access denied. Please allow microphone access and try again.';
+                    this.recordingStatus.style.color = '#ff4757';
                 }
             }
 
             stopRecording() {
                 if (!this.isRecording || !this.mediaRecorder) return;
 
+                console.log('Stopping recording...');
                 this.mediaRecorder.stop();
                 this.isRecording = false;
 
@@ -685,27 +743,50 @@
                 this.micButton.classList.remove('recording');
                 this.micIcon.textContent = '🎤';
                 this.recordingStatus.textContent = 'Processing audio...';
+                this.recordingStatus.style.color = '#666';
             }
 
             async processRecording() {
-                const audioBlob = new Blob(this.audioChunks, { type: 'audio/wav' });
-                const formData = new FormData();
-                formData.append('audio', audioBlob, 'recording.wav');
-
                 try {
+                    if (this.audioChunks.length === 0) {
+                        console.error('No audio chunks recorded');
+                        this.recordingStatus.textContent = 'No audio recorded. Please try again.';
+                        return;
+                    }
+
+                    console.log('Processing', this.audioChunks.length, 'audio chunks');
+
+                    // Create blob from audio chunks
+                    const audioBlob = new Blob(this.audioChunks, { type: 'audio/webm' });
+                    console.log('Created audio blob:', audioBlob.size, 'bytes');
+
+                    if (audioBlob.size === 0) {
+                        console.error('Audio blob is empty');
+                        this.recordingStatus.textContent = 'No audio data captured. Please try again.';
+                        return;
+                    }
+
+                    const formData = new FormData();
+                    formData.append('audio', audioBlob, 'recording.webm');
+
+                    console.log('Sending audio for transcription...');
                     const response = await fetch('/api/transcribe_audio', {
                         method: 'POST',
                         body: formData
                     });
 
                     if (!response.ok) {
+                        const errorText = await response.text();
+                        console.error('Transcription error:', response.status, errorText);
                         throw new Error(`HTTP error! status: ${response.status}`);
                     }
 
                     const data = await response.json();
+                    console.log('Transcription response:', data);
 
                     if (data.error) {
                         this.recordingStatus.textContent = data.error;
+                        this.recordingStatus.style.color = '#ff4757';
                         return;
                     }
 
@@ -714,13 +795,16 @@
                         this.confirmButton.disabled = false;
                         this.retryButton.style.display = 'inline-flex';
                         this.recordingStatus.textContent = 'Transcription complete. Review and confirm your answer.';
+                        this.recordingStatus.style.color = '#4CAF50';
                     } else {
                         this.recordingStatus.textContent = 'No speech detected. Please try recording again.';
+                        this.recordingStatus.style.color = '#ff4757';
                     }
 
                 } catch (error) {
                     console.error('Error processing recording:', error);
                     this.recordingStatus.textContent = 'Error processing audio. Please try again.';
+                    this.recordingStatus.style.color = '#ff4757';
                 }
             }
 
@@ -729,12 +813,15 @@
                 this.confirmButton.disabled = true;
                 this.retryButton.style.display = 'none';
                 this.recordingStatus.textContent = 'Click and hold to record your answer';
+                this.recordingStatus.style.color = '#666';
             }
 
             async submitAnswer() {
                 const answer = this.transcriptArea.textContent.trim();
                 if (!answer) return;
 
+                console.log('Submitting answer:', answer);
+
                 // Show loading state
                 this.confirmButton.disabled = true;
                 this.confirmLoading.style.display = 'inline-block';
@@ -751,18 +838,22 @@
                         },
                         body: JSON.stringify({
                             answer: answer,
-                            questionIndex: this.currentQuestionIndex
+                            questionIndex: this.currentQuestionIndex,
+                            current_question: this.currentQuestion
                         })
                     });
 
                     if (!response.ok) {
+                        const errorText = await response.text();
+                        console.error('Process answer error:', response.status, errorText);
                         throw new Error(`HTTP error! status: ${response.status}`);
                     }
 
-                    // Parse JSON response
                     const data = await response.json();
+                    console.log('Process answer response:', data);
+
                     if (!data.success) {
-                        this.showError('Failed to process answer. Please try again.');
+                        this.showError(data.error || 'Failed to process answer. Please try again.');
                         return;
                     }
 
@@ -771,11 +862,12 @@
                     this.interviewData.evaluations.push(data.evaluation || {});
 
                     if (data.is_complete) {
-                        // Interview finished, show summary
+                        console.log('Interview completed');
                         this.showInterviewSummary();
                     } else {
-                        // Advance to next question
+                        console.log('Moving to next question');
                         this.currentQuestionIndex++;
+                        this.currentQuestion = data.next_question;
                         this.displayQuestion(data.next_question, data.audio_url);
                         this.interviewData.questions.push(data.next_question);
                         this.resetForNextQuestion();
@@ -794,10 +886,10 @@
                 const messageDiv = document.createElement('div');
                 messageDiv.className = 'user-message';
                 messageDiv.innerHTML = `
-                    <div class="user-bubble">
-                        <p>${message}</p>
-                    </div>
-                `;
+            <div class="user-bubble">
+                <p>${message}</p>
+            </div>
+        `;
                 this.chatArea.appendChild(messageDiv);
                 this.chatArea.scrollTop = this.chatArea.scrollHeight;
             }
@@ -807,6 +899,7 @@
                 this.confirmButton.disabled = true;
                 this.retryButton.style.display = 'none';
                 this.recordingStatus.textContent = 'Wait for the next question...';
+                this.recordingStatus.style.color = '#666';
                 this.micButton.disabled = true;
             }
 
@@ -819,14 +912,14 @@
                     const evaluation = this.interviewData.evaluations[index] || {};
 
                     summaryHtml += `
-                        <div class="summary-item">
-                            <h4>Question ${index + 1}:</h4>
-                            <p><strong>Q:</strong> ${question}</p>
-                            <p><strong>A:</strong> ${answer}</p>
-                            <p><strong>Score:</strong> <span class="evaluation-score">${evaluation.score || 'N/A'}</span></p>
-                            <p><strong>Feedback:</strong> ${evaluation.feedback || 'No feedback provided'}</p>
-                        </div>
-                    `;
+                <div class="summary-item">
+                    <h4>Question ${index + 1}:</h4>
+                    <p><strong>Q:</strong> ${question}</p>
+                    <p><strong>A:</strong> ${answer}</p>
+                    <p><strong>Score:</strong> <span class="evaluation-score">${evaluation.score || 'N/A'}</span></p>
+                    <p><strong>Feedback:</strong> ${evaluation.feedback || 'No feedback provided'}</p>
+                </div>
+            `;
                 });
 
                 summaryContent.innerHTML = summaryHtml;
@@ -837,6 +930,8 @@
             }
 
             showError(message) {
+                console.error('Showing error:', message);
+
                 // Create error message element
                 const errorDiv = document.createElement('div');
                 errorDiv.className = 'error-message';
@@ -864,6 +959,7 @@
 
         // Initialize the interview when page loads
         document.addEventListener('DOMContentLoaded', () => {
+            console.log('DOM loaded, initializing AI Interviewer...');
             new AIInterviewer();
         });
 

requirements.txt

@@ -53,4 +53,10 @@ edge-tts==6.1.2
 
 # Additional Flask dependencies
 gunicorn
-python-dotenv
+python-dotenv
+
+# Audio format conversion (critical for WebM/WAV handling)
+pydub>=0.25.1
+
+# Better error handling for API calls
+requests>=2.31.0