Added logging and caps responses at 800 characters in answer validation to ensure no "thinking" answers

researchsimulation/InteractiveInterviewChatbot.py

@@ -1,6 +1,7 @@
 import gradio as gr
 import logging
 import re
+import time
 
 from RespondentAgent import *
 from langchain_groq import ChatGroq
@@ -16,9 +17,11 @@ def parse_question_with_llm(question, respondent_names, processor_llm):
     Uses OpenAI's LLM to extract the specific agents being addressed and their respective questions.
     Supports compound requests.
     """
-    logging.info("🔍 ENTERING: parse_question_with_llm()")
-    logging.info(f"Received user input: {question}")
-    logging.info(f"Available respondent names: {respondent_names}")
+    logging.info("[parse_question_with_llm] Entry")
+    logging.debug(f"[parse_question_with_llm] Input question: {question}")
+    logging.debug(f"[parse_question_with_llm] Available respondent names: {respondent_names}")
+
+    start_time = time.time()
     
     prompt = f"""
     You are an expert in market research interview analysis.
@@ -61,24 +64,29 @@ def parse_question_with_llm(question, respondent_names, processor_llm):
     
     Only return the formatted output without explanations.
     """
-    
-    logging.info("Prompt constructed. Invoking LLM now...")
 
+    logging.debug("[parse_question_with_llm] Prompt constructed successfully.")
+    logging.debug(f"[parse_question_with_llm] Prompt preview: {prompt[:500]}...")
+
+    logging.info("Prompt constructed. Invoking LLM now...")
     try:
         response = processor_llm.invoke(prompt)
+        duration = time.time() - start_time
+        logging.info(f"[parse_question_with_llm] LLM call completed in {duration:.2f} seconds.")
+        
         if not hasattr(response, "content") or not response.content:
-            logging.error("LLM response is empty or malformed.")
+            logging.error("[parse_question_with_llm] ERROR: LLM response is empty or malformed.")
             return {}
 
         chatgpt_output = response.content.strip()
-        logging.info(f"Raw LLM Output:\n{chatgpt_output}")
+        logging.info(f"[parse_question_with_llm] Raw LLM output: {chatgpt_output}")
 
     except Exception as e:
-        logging.exception(f"Exception occurred during LLM invocation in parse_question_with_llm: {e}")
+        logging.exception("[parse_question_with_llm] Exception during LLM invocation.")
         return {}
 
     # Begin parsing the structured response
-    logging.info("Parsing LLM output for respondent-question pairs...")
+    logging.info("[parse_question_with_llm] Parsing LLM output for respondent-question pairs.")
     
     parsed_questions = {}
     respondent_name = "General"
@@ -87,19 +95,20 @@ def parse_question_with_llm(question, respondent_names, processor_llm):
     for line in chatgpt_output.split("\n"):
         if "- Respondent:" in line:
             respondent_name = re.sub(r"^.*Respondent:\s*", "", line).strip().capitalize()
+            logging.debug(f"[parse_question_with_llm] Detected respondent: {respondent_name}")
         elif "Question:" in line:
             question_text = re.sub(r"^.*Question:\s*", "", line).strip()
             if respondent_name and question_text:
                 parsed_questions[respondent_name] = question_text
-                logging.info(f"Parsed -> Respondent: {respondent_name}, Question: {question_text}")
+                logging.info(f"[parse_question_with_llm] Parsed pair: Respondent={respondent_name}, Question={question_text}")
                 respondent_name = "General"
                 question_text = None
     
     if not parsed_questions:
-        logging.warning("No respondent-question pairs were successfully parsed.")
+        logging.warning("[parse_question_with_llm] WARNING: No respondent-question pairs parsed.")
 
-    logging.info(f"Final parsed questions: {parsed_questions}")
-    logging.info("Exiting parse_question_with_llm()")
+    logging.info(f"[parse_question_with_llm] Final parsed questions: {parsed_questions}")
+    logging.info("[parse_question_with_llm] Exit")
     return parsed_questions
 
 def validate_question_topics(parsed_questions, processor_llm):
@@ -108,13 +117,15 @@ def validate_question_topics(parsed_questions, processor_llm):
     Converts question to British English spelling if valid.
     Returns 'INVALID' for any out-of-scope question.
     """
-    logging.info("ENTERING: validate_question_topics()")
-    logging.info("Starting question validation against permitted scope...")
+    logging.info("[validate_question_topics] Entry")
+    logging.debug(f"[validate_question_topics] Input parsed_questions: {parsed_questions}")
     
     validated_questions = {}
 
     for respondent, question in parsed_questions.items():
-        logging.info(f"Validating question for {respondent}: {question}")
+        logging.info(f"[validate_question_topics] Processing respondent: {respondent}")
+        logging.debug(f"[validate_question_topics] Original question: {question}")
+        
         prompt = f"""
         You are a senior research analyst. Your job is to **validate** whether a market research question is within the allowed topic scope and convert it to **British English** spelling, grammar, and phrasing.
         ### Question:
@@ -180,26 +191,36 @@ def validate_question_topics(parsed_questions, processor_llm):
         #    - Strictly do not add to the question other than rewriting to **British English**.
         # ### Output:
         # <Validated question in British English, or "INVALID">
-        
+
+        logging.debug(f"[validate_question_topics] Prompt constructed for {respondent}.")
+        logging.debug(f"[validate_question_topics] Prompt preview: {prompt[:500]}...")
+
         try:
-            logging.debug("Sending validation prompt to LLM...")
+            logging.info(f"[validate_question_topics] Invoking LLM for {respondent}")
+            llm_start = time.time()
             response = processor_llm.invoke(prompt)
+            llm_duration = time.time() - llm_start
+            logging.info(f"[validate_question_topics] LLM call completed for {respondent} in {llm_duration:.2f} seconds")
 
             if not hasattr(response, "content") or not response.content:
-                logging.error(f"Empty or malformed response from LLM for respondent: '{respondent}'")
+                logging.error(f"[validate_question_topics] ERROR: Empty or malformed response from LLM for '{respondent}'")
                 validated_output = "INVALID"
             else:
                 validated_output = response.content.strip()
-                logging.info(f"Validation output for '{respondent}': {validated_output}")
+                logging.debug(f"[validate_question_topics] Raw LLM output for {respondent}: {validated_output}")
 
         except Exception as e:
-            logging.exception(f"Exception during validation for respondent '{respondent}': {e}")
+            logging.exception(f"[validate_question_topics] Exception during LLM invocation for respondent '{respondent}'")
             validated_output = "INVALID"
 
         validated_questions[respondent] = validated_output
+        logging.info(f"[validate_question_topics] Validation result for {respondent}: {validated_output}")
+
+    total_duration = time.time() - start_time
+    logging.info(f"[validate_question_topics] Completed validation for all questions in {total_duration:.2f} seconds.")
+    logging.debug(f"[validate_question_topics] Final validated questions: {validated_questions}")
+    logging.info("[validate_question_topics] Exit")
 
-    logging.info("Completed validation for all questions.")
-    logging.debug(f"Final validated questions dictionary:\n{validated_questions}")
     return validated_questions
 
 
@@ -208,89 +229,156 @@ def generate_generic_answer(agent_name, agent_question, respondent_agent):
     """
     Generates a raw, content-only answer with no stylistic or emotional tailoring.
     """
-    task_description = f"""
-You are {agent_name}. Respond to the market research interview question below using only factual, content-relevant information based on your personal experience.
-
----
-### Question:
-"{agent_question}"
-
----
-### Instructions:
-- Answer **only what is asked** in the question.
-- Do **not** include any specific communication style, tone, or emotional expression.
-- Your answer must be **clear, concise, and factually accurate**.
-- Use **first-person ("I", "my", etc.)** and speak as yourself.
-- Do **not** include introductions, conclusions, opinions, or embellishments.
-- Use strict **British English** spelling and grammar.
-- **Do not** reference your own name or include placeholders like [Your Name].
-
----
-Your goal is to provide a direct, stylistically neutral answer to: "{agent_question}"
-    """
 
-    task = Task(description=task_description, expected_output="A neutral, personal response to the question.", agent=respondent_agent)
-    Crew(agents=[respondent_agent], tasks=[task], process=Process.sequential).kickoff()
-    output = task.output
-    return output.raw if hasattr(output, "raw") else str(output)
+    logging.info("[generate_generic_answer] Entry")
+    logging.debug(f"[generate_generic_answer] Parameters: agent_name={agent_name}, agent_question={agent_question}")
+    start_time = time.time()
+
+    try:
+        # --- Build task description ---
+        logging.info("[generate_generic_answer] Constructing task description")
+        task_description = f"""
+        You are {agent_name}. Respond to the market research interview question below using only factual, content-relevant information based on your personal experience.
+        
+        ---
+        ### Question:
+        "{agent_question}"
+        
+        ---
+        ### Instructions:
+        - Answer **only what is asked** in the question.
+        - Do **not** include any specific communication style, tone, or emotional expression.
+        - Your answer must be **clear, concise, and factually accurate**.
+        - Use **first-person ("I", "my", etc.)** and speak as yourself.
+        - Do **not** include introductions, conclusions, opinions, or embellishments.
+        - Use strict **British English** spelling and grammar.
+        - **Do not** reference your own name or include placeholders like [Your Name].
+        
+        ---
+        Your goal is to provide a direct, stylistically neutral answer to: "{agent_question}"
+        """
+
+        logging.debug(f"[generate_generic_answer] Task description preview: {task_description[:300]}...")
+        
+        task = Task(description=task_description, expected_output="A neutral, personal response to the question.", agent=respondent_agent)
+        Crew(agents=[respondent_agent], tasks=[task], process=Process.sequential)
+        
+        logging.info("[generate_generic_answer] Starting Crew kickoff")
+        kickoff_start = time.time()
+        crew.kickoff()
+        kickoff_duration = time.time() - kickoff_start
+        logging.info(f"[generate_generic_answer] Crew kickoff completed in {kickoff_duration:.2f} seconds")
+
+        # --- Retrieve output ---
+        output = task.output
+        if hasattr(output, "raw"):
+            result = output.raw
+        else:
+            result = str(output)
+
+        logging.debug(f"[generate_generic_answer] Raw output: {result}")
+
+    except Exception as e:
+        logging.exception("[generate_generic_answer] Exception occurred during Crew execution")
+        result = "Sorry, something went wrong while generating the answer."
+
+    total_duration = time.time() - start_time
+    logging.info(f"[generate_generic_answer] Completed in {total_duration:.2f} seconds")
+    logging.info("[generate_generic_answer] Exit")
+    return result
 
 
 def tailor_answer_to_profile(agent_name, generic_answer, agent_question, user_profile, respondent_agent):
     """
     Enhances the generic answer to match the respondent's communication profile and personality traits.
     """
-    style = user_profile.get_field("Communication", "Style")
-    tone = user_profile.get_field("Communication", "Tone")
-    length = user_profile.get_field("Communication", "Length")
-    topics = user_profile.get_field("Communication", "Topics")
-
-    task_description = f"""
-You are {agent_name}. Rewrite the following answer to match your personal communication style and tone preferences.
-
----
-### Original Generic Answer:
-{generic_answer}
-
----
-### Question:
-"{agent_question}"
-
----
-### *Communication Profile Reference:*
-- **Style:** {style}
-- **Tone:** {tone}
-- **Length:** {length}
-- **Topics:** {topics}
-
----
-### 🔒 Hard Rules – You Must Follow These Without Exception:
-- Keep the **meaning** and **personal point of view** of the original answer.
-- Do **not** introduce new information or elaborate beyond what’s stated.
-- Use **first person** ("I", "my", etc.) — never speak in third person.
-- Always use **British English** spelling, punctuation, and grammar.
-- Match the specified **style**, **tone**, and **length**.
-- Keep the response **natural, personal, and culturally authentic**.
-- Do **not** include emojis, hashtags, placeholders, or third-person descriptions.
-- Maintain **narrative consistency** across responses to reflect a coherent personality.
-- Tailor phrasing, sentence structure, and vocabulary to fit your **persona** and **communication traits**.
-
----
-### Personality Trait Alignment:
-Ensure your answer reflects these aspects of your personality profile:
-- Big Five Traits (e.g., Openness, Extraversion)
-- Values and Priorities (e.g., Risk Tolerance, Achievement Orientation)
-- Communication Preferences (e.g., Directness, Emotional Expressiveness)
-
----
-Final Output:
-A single paragraph answer that matches the respondent’s tone and style, while strictly preserving the original meaning and personal voice from this answer:
-**"{generic_answer}"**
-    """
+    logging.info("[tailor_answer_to_profile] Entry")
+    logging.debug(f"[tailor_answer_to_profile] Parameters: agent_name={agent_name}, agent_question={agent_question}")
+    logging.debug(f"[tailor_answer_to_profile] generic_answer: {generic_answer}")
+    logging.debug(f"[tailor_answer_to_profile] user_profile: {user_profile}")
 
-    task = Task(description=task_description, expected_output="A styled, culturally authentic, first-person response.", agent=respondent_agent)
-    Crew(agents=[respondent_agent], tasks=[task], process=Process.sequential).kickoff()
-    output = task.output
-    return output.raw if hasattr(output, "raw") else str(output)
+    start_time = time.time()
+
+    try:
+        # --- Build task description ---
+        logging.info("[tailor_answer_to_profile] Constructing task description")
+        style = user_profile.get_field("Communication", "Style")
+        tone = user_profile.get_field("Communication", "Tone")
+        length = user_profile.get_field("Communication", "Length")
+        topics = user_profile.get_field("Communication", "Topics")
+
+        task_description = f"""
+        You are {agent_name}. Rewrite the following answer to match your personal communication style and tone preferences.
+        
+        ---
+        ### Original Generic Answer:
+        {generic_answer}
+        
+        ---
+        ### Question:
+        "{agent_question}"
+        
+        ---
+        ### *Communication Profile Reference:*
+        - **Style:** {style}
+        - **Tone:** {tone}
+        - **Length:** {length}
+        - **Topics:** {topics}
+        
+        ---
+        ### Hard Rules – You Must Follow These Without Exception:
+        - Keep the **meaning** and **personal point of view** of the original generic answer.
+        - Do **not** introduce new information or elaborate beyond what’s stated.
+        - Use **first person** ("I", "my", etc.) — never speak in third person.
+        - Always use **British English** spelling, punctuation, and grammar.
+        - Match the specified **style**, **tone**, and **length**.
+        - Keep the response **natural, personal, and culturally authentic**.
+        - Do **not** include emojis, hashtags, placeholders, or third-person descriptions.
+        - Maintain **narrative consistency** across responses to reflect a coherent personality.
+        - Tailor phrasing, sentence structure, and vocabulary to fit your **persona** and **communication traits**.
+        
+        ---
+        ### Personality Trait Alignment:
+        Ensure your answer reflects these aspects of your personality profile:
+        - Big Five Traits (e.g., Openness, Extraversion)
+        - Values and Priorities (e.g., Risk Tolerance, Achievement Orientation)
+        - Communication Preferences (e.g., Directness, Emotional Expressiveness)
+        
+        ---
+        Final Output:
+        A single paragraph answer that matches the respondent’s tone and style, while strictly preserving the original meaning and personal voice from this answer:
+        **"{generic_answer}"**
+        """
+        
+        logging.debug(f"[tailor_answer_to_profile] Task description preview: {task_description[:300]}...")
+        logging.info("[tailor_answer_to_profile] Initialising Task and Crew objects")
+        
+        task = Task(description=task_description, expected_output="A styled, culturally authentic, first-person response.", agent=respondent_agent)
+        Crew(agents=[respondent_agent], tasks=[task], process=Process.sequential)
+        
+        logging.info("[tailor_answer_to_profile] Starting Crew kickoff")
+        kickoff_start = time.time()
+        crew.kickoff()
+        kickoff_duration = time.time() - kickoff_start
+        logging.info(f"[tailor_answer_to_profile] Crew kickoff completed in {kickoff_duration:.2f} seconds")
+
+        # --- Retrieve output ---
+        output = task.output
+        if hasattr(output, "raw"):
+            result = output.raw
+        else:
+            result = str(output)
+
+        logging.debug(f"[tailor_answer_to_profile] Raw output: {result}")
+
+    except Exception as e:
+        logging.exception("[tailor_answer_to_profile] Exception occurred during Crew execution")
+        result = "Sorry, something went wrong while generating the styled answer."
+
+    total_duration = time.time() - start_time
+    logging.info(f"[tailor_answer_to_profile] Completed in {total_duration:.2f} seconds")
+    logging.info("[tailor_answer_to_profile] Exit")
+    return result
 
 
 def validate_tailored_answer(agent_name, agent_question, respondent_agent, tailored_answer_generator, user_profile, processor_llm, max_attempts=3):
@@ -298,20 +386,30 @@ def validate_tailored_answer(agent_name, agent_question, respondent_agent, tailo
     Re-generates and validates the respondent's tailored answer with retry logic.
     Returns the validated answer, or a fallback string if validation fails after max_attempts.
     """
+    logging.info("[validate_tailored_answer] Entry")
+    logging.debug(f"[validate_tailored_answer] Parameters: agent_name={agent_name}, agent_question={agent_question}, max_attempts={max_attempts}")
+
     attempt = 0
     validated = False
     validated_answer = None
+    overall_start = time.time()
 
     while attempt < max_attempts and not validated:
+        logging.info(f"[validate_tailored_answer] Starting attempt {attempt+1} of {max_attempts}")
+        attempt_start = time.time()
+        
         try:
-            logging.info(f"Attempt {attempt+1}: Generating and validating answer for '{agent_name}'")
-
+            logging.info(f"[validate_tailored_answer] Attempt {attempt+1}: Generating and validating answer for '{agent_name}'")
+            gen_start = time.time()
             # Generate tailored answer from generic → styled
             tailored_answer = tailored_answer_generator()
-
-            logging.debug(f"Generated tailored answer (attempt {attempt+1}): {tailored_answer}")
+            gen_duration = time.time() - gen_start
+            logging.info(f"[validate_tailored_answer] Tailored answer generation completed in {gen_duration:.2f} seconds")
+            logging.debug(f"[validate_tailored_answer] Tailored answer (attempt {attempt+1}): {tailored_answer}")
 
             # Validate response
+            logging.info(f"[validate_tailored_answer] Validating answer (attempt {attempt+1})")
+            val_start = time.time()
             is_valid = validate_response(
                 question=agent_question,
                 answer=tailored_answer,
@@ -322,25 +420,42 @@ def validate_tailored_answer(agent_name, agent_question, respondent_agent, tailo
                 ai_evaluator_agent=None, 
                 processor_llm=processor_llm
             )
-
-            logging.info(f"Validation result for attempt {attempt+1}: {is_valid}")
+            val_duration = time.time() - val_start
+            logging.info(f"[validate_tailored_answer] Validation completed in {val_duration:.2f} seconds")
+            logging.info(f"[validate_tailored_answer] Validation result for attempt {attempt+1}: {is_valid}")
 
             if is_valid:
-                validated = True
-                validated_answer = tailored_answer
-                break
+                if len(tailored_answer) > 800:
+                    logging.warning(f"Tailored answer exceeds 800 characters (length={len(tailored_answer)}); retrying...")
+                    attempt += 1
+                else:
+                    validated = True
+                    validated_answer = tailored_answer
+                    logging.info(f"Answer validated successfully on attempt {attempt+1}")
+                    break
             else:
-                logging.warning(f"Validation failed for attempt {attempt+1}")
+                logging.warning(f"Validation failed on attempt {attempt+1}")
                 attempt += 1
 
         except Exception as e:
-            logging.error(f"Error on validation attempt {attempt+1} for '{agent_name}': {e}", exc_info=True)
+            logging.exception(f"[validate_tailored_answer] Exception on attempt {attempt+1}")
             attempt += 1
 
+        attempt_duration = time.time() - attempt_start
+        logging.info(f"[validate_tailored_answer] Attempt {attempt+1} duration: {attempt_duration:.2f} seconds")
+
+    overall_duration = time.time() - overall_start    
+    
     if validated_answer:
-        return f"**{agent_name}**: {validated_answer}"
+        final_response = f"**{agent_name}**: {validated_answer}"
+        logging.info(f"[validate_tailored_answer] Successfully returning validated answer after {overall_duration:.2f} seconds")
     else:
-        return f"**PreData Moderator**: Unable to pass validation after {max_attempts} attempts for {agent_name}."
+        final_response = f"**PreData Moderator**: Unable to pass validation after {max_attempts} attempts for {agent_name}."
+        logging.warning(f"[validate_tailored_answer] Returning failure message after {overall_duration:.2f} seconds")
+
+    logging.debug(f"[validate_tailored_answer] Final response: {final_response}")
+    logging.info("[validate_tailored_answer] Exit")
+    return final_response
 
 def ask_interview_question(respondent_agents_dict, last_active_agent, question, processor_llm):
     """
@@ -348,70 +463,115 @@ def ask_interview_question(respondent_agents_dict, last_active_agent, question,
     Uses OpenAI's LLM to extract the intended respondent(s) and their specific question(s).
     Generates generic answers, styles them, and validates the output.
     """
+    logging.info("[ask_interview_question] Entry")
+    logging.debug(f"[ask_interview_question] Parameters: question={question}, last_active_agent={last_active_agent}")
 
-    logging.info(f"Received question: {question}")
-
-    agent_names = list(respondent_agents_dict.keys())
-    logging.info(f"Available respondents: {agent_names}")
-    print(f"Available respondents: {agent_names}")
-
-    # Step 1: Parse question
-    parsed_questions = parse_question_with_llm(question, str(agent_names), processor_llm)
-    if not parsed_questions:
-        logging.warning("No questions were parsed from input.")
-        return ["**PreData Moderator**: No valid respondents were detected for this question."]
-
-    # Step 2: Validate topics and spelling
-    validated_questions = validate_question_topics(parsed_questions, processor_llm)
-    for resp_name, extracted_question in validated_questions.items():
-        if extracted_question == "INVALID":
-            logging.warning(f"Invalid question detected for {resp_name}: {extracted_question}")
-            return ["**PreData Moderator**: The question is invalid. Please ask another question."]
-
-    # Handle "General" or "All"
-    if len(validated_questions) > 1:
-        return ["**PreData Moderator**: Please ask each respondent one question at a time."]
-
-    if "General" in validated_questions:
-        if isinstance(last_active_agent, list) and all(name in agent_names for name in last_active_agent):
-            validated_questions = {name: validated_questions["General"] for name in last_active_agent}
-        else:
-            validated_questions = {name: validated_questions["General"] for name in agent_names}
-
-    elif "All" in validated_questions:
-        validated_questions = {name: validated_questions["All"] for name in agent_names}
+    overall_start = time.time()
 
-    # Update last_active_agent
-    last_active_agent = list(validated_questions.keys())
-
-    responses = []
-    for agent_name, agent_question in validated_questions.items():
-        if agent_name not in respondent_agents_dict:
-            responses.append(f"**PreData Moderator**: {agent_name} is not a valid respondent.")
-            continue
+    try:
+        agent_names = list(respondent_agents_dict.keys())
+        logging.info(f"[ask_interview_question] Available respondents: {agent_names}")
+
+        # --- Step 1: Parse question ---
+        logging.info("[ask_interview_question] Parsing question with LLM")
+        parse_start = time.time()
+        parsed_questions = parse_question_with_llm(question, str(agent_names), processor_llm)
+        parse_duration = time.time() - parse_start
+        logging.info(f"[ask_interview_question] Parsing completed in {parse_duration:.2f} seconds")
+        logging.debug(f"[ask_interview_question] Parsed questions: {parsed_questions}")
+
+        if not parsed_questions:
+            logging.warning("[ask_interview_question] No questions were parsed from input.")
+            return ["**PreData Moderator**: No valid respondents were detected for this question."]
+
+        # --- Step 2: Validate topics and spelling ---
+        logging.info("[ask_interview_question] Validating parsed questions")
+        validation_start = time.time()
+        validated_questions = validate_question_topics(parsed_questions, processor_llm)
+        validation_duration = time.time() - validation_start
+        logging.info(f"[ask_interview_question] Validation completed in {validation_duration:.2f} seconds")
+        logging.debug(f"[ask_interview_question] Validated questions: {validated_questions}")
+
+        for resp_name, extracted_question in validated_questions.items():
+            if extracted_question == "INVALID":
+                logging.warning(f"[ask_interview_question] Invalid question detected for {resp_name}: {extracted_question}")
+                return ["**PreData Moderator**: The question is invalid. Please ask another question."]
+
+        # --- Handle "General" or "All" ---
+        if len(validated_questions) > 1:
+            logging.warning("[ask_interview_question] Multiple respondents detected in single question")
+            return ["**PreData Moderator**: Please ask each respondent one question at a time."]
+
+        if "General" in validated_questions:
+            logging.info("[ask_interview_question] Handling 'General' question")
+            if isinstance(last_active_agent, list) and all(name in agent_names for name in last_active_agent):
+                validated_questions = {name: validated_questions["General"] for name in last_active_agent}
+            else:
+                validated_questions = {name: validated_questions["General"] for name in agent_names}
+            logging.debug(f"[ask_interview_question] Expanded to: {validated_questions}")
+
+        elif "All" in validated_questions:
+            logging.info("[ask_interview_question] Handling 'All' question")
+            validated_questions = {name: validated_questions["All"] for name in agent_names}
+            logging.debug(f"[ask_interview_question] Expanded to: {validated_questions}")
+
+        # --- Update last_active_agent ---
+        last_active_agent = list(validated_questions.keys())
+        logging.info(f"[ask_interview_question] Updated last_active_agent: {last_active_agent}")
+
+        # --- Step 3: Generate + Tailor answers ---
+        responses = []
+        for agent_name, agent_question in validated_questions.items():
+            logging.info(f"[ask_interview_question] Processing respondent: {agent_name}")
+            generation_start = time.time()
+
+            if agent_name not in respondent_agents_dict:
+                logging.warning(f"[ask_interview_question] Invalid respondent name detected: {agent_name}")
+                responses.append(f"**PreData Moderator**: {agent_name} is not a valid respondent.")
+                continue
+
+            respondent_agent = respondent_agents_dict[agent_name].get_agent()
+            user_profile = respondent_agents_dict[agent_name].get_user_profile()
+
+            # --- Generate Generic Answer ---
+            logging.info(f"[ask_interview_question] Generating generic answer for {agent_name}")
+            generic_answer = generate_generic_answer(agent_name, agent_question, respondent_agent)
+            logging.debug(f"[ask_interview_question] Generic answer: {generic_answer}")
+
+            # --- Tailor + Validate with Retry ---
+            def generator():
+                return tailor_answer_to_profile(agent_name, generic_answer, agent_question, user_profile, respondent_agent)
+
+            logging.info(f"[ask_interview_question] Tailoring and validating answer for {agent_name}")
+            validated_response = validate_tailored_answer(
+                agent_name=agent_name,
+                agent_question=agent_question,
+                respondent_agent=respondent_agent,
+                tailored_answer_generator=generator,
+                user_profile=user_profile,
+                processor_llm=processor_llm
+            )
+            logging.debug(f"[ask_interview_question] Validated response: {validated_response}")
 
-        respondent_agent = respondent_agents_dict[agent_name].get_agent()
-        user_profile = respondent_agents_dict[agent_name].get_user_profile()
+            responses.append(validated_response)
+            generation_duration = time.time() - generation_start
+            logging.info(f"[ask_interview_question] Completed generation + validation for {agent_name} in {generation_duration:.2f} seconds")
 
-        # Step 1: Generate Generic Answer
-        generic_answer = generate_generic_answer(agent_name, agent_question, respondent_agent)
+        # --- Format final return ---
+        if len(set(validated_questions.values())) == 1:
+            result = ["\n\n".join(responses)]
+        else:
+            result = responses
 
-        # Step 2 & 3: Tailor + Validate with Retry
-        def generator():
-            return tailor_answer_to_profile(agent_name, generic_answer, agent_question, user_profile, respondent_agent)
+        logging.info("[ask_interview_question] Successfully generated all responses")
+        logging.debug(f"[ask_interview_question] Final responses: {result}")
 
-        validated_response = validate_tailored_answer(
-            agent_name=agent_name,
-            agent_question=agent_question,
-            respondent_agent=respondent_agent,
-            tailored_answer_generator=generator,
-            user_profile=user_profile,
-            processor_llm=processor_llm
-        )
+    except Exception as e:
+        logging.exception("[ask_interview_question] Exception occurred during processing")
+        result = ["**PreData Moderator**: An unexpected error occurred while processing the question."]
 
-        responses.append(validated_response)
+    overall_duration = time.time() - overall_start
+    logging.info(f"[ask_interview_question] Completed in {overall_duration:.2f} seconds")
+    logging.info("[ask_interview_question] Exit")
 
-    if len(set(validated_questions.values())) == 1:
-        return ["\n\n".join(responses)]
-    else:
-        return responses
+    return result