Update researchsimulation/InteractiveInterviewChatbot.py

researchsimulation/InteractiveInterviewChatbot.py

@@ -391,88 +391,47 @@ def tailor_answer_to_profile(agent_name, generic_answer, agent_question, user_pr
     return result
 
 
-def validate_tailored_answer(agent_name, agent_question, respondent_agent, tailored_answer_generator, user_profile, processor_llm, max_attempts=3):
-    """
-    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"[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()
-            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,
-                user_profile_str=str(user_profile),
-                fast_facts_str="", 
-                interview_transcript_text="",  
-                respondent_type=agent_name,
-                ai_evaluator_agent=None, 
-                processor_llm=processor_llm
-            )
-            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:
-                if len(tailored_answer) > 2000:
-                    logging.warning(f"Tailored answer exceeds 2000 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 on attempt {attempt+1}")
-                attempt += 1
-
-        except Exception as e:
-            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:
-        final_response = f"**{agent_name}**: {validated_answer}"
-        logging.info(f"[validate_tailored_answer] Successfully returning validated answer after {overall_duration:.2f} seconds")
-    else:
-        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")
+# --- New Validation Functions ---
+def validate_generic_answer(agent_name, agent_question, generic_answer, user_profile, processor_llm):
+    logging.info("[validate_generic_answer] Entry")
+    try:
+        is_valid = validate_response(
+            question=agent_question,
+            answer=generic_answer,
+            user_profile_str=str(user_profile),
+            fast_facts_str="", 
+            interview_transcript_text="",  
+            respondent_type=agent_name,
+            ai_evaluator_agent=None,
+            processor_llm=processor_llm
+        )
+        logging.info(f"[validate_generic_answer] Result: {is_valid}")
+        return is_valid
+    except Exception as e:
+        logging.exception("[validate_generic_answer] Exception during validation")
+        return False
 
-    logging.debug(f"[validate_tailored_answer] Final response: {final_response}")
-    logging.info("[validate_tailored_answer] Exit")
-    return final_response
+def validate_styled_answer(agent_name, agent_question, styled_answer, user_profile, processor_llm):
+    logging.info("[validate_styled_answer] Entry")
+    try:
+        is_valid = validate_response(
+            question=agent_question,
+            answer=styled_answer,
+            user_profile_str=str(user_profile),
+            fast_facts_str="", 
+            interview_transcript_text="",  
+            respondent_type=agent_name,
+            ai_evaluator_agent=None,
+            processor_llm=processor_llm
+        )
+        logging.info(f"[validate_styled_answer] Result: {is_valid}")
+        return is_valid
+    except Exception as e:
+        logging.exception("[validate_styled_answer] Exception during style validation")
+        return False
 
+# --- Updated ask_interview_question Function ---
 def ask_interview_question(respondent_agents_dict, last_active_agent, question, processor_llm):
-    """
-    Handles both individual and group interview questions while tracking conversation flow.
-    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}")
 
@@ -482,99 +441,70 @@ def ask_interview_question(respondent_agents_dict, last_active_agent, question,
         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()
 
+        for agent_name, agent_question in validated_questions.items():
             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 ---
+            if not validate_generic_answer(agent_name, agent_question, generic_answer, user_profile, processor_llm):
+                responses.append(f"**PreData Moderator**: The generated answer for {agent_name} did not meet our content standards.")
+                continue
+
             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}")
-
-            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")
-
-        # --- Format final return ---
-        if len(set(validated_questions.values())) == 1:
-            result = ["\n\n".join(responses)]
-        else:
-            result = responses
+            tailored_attempts = 0
+            max_tailored_attempts = 3
+            tailored_answer = None
+
+            while tailored_attempts < max_tailored_attempts:
+                styled = generator()
+
+                if len(styled) > 2000:
+                    logging.warning(f"[ask_interview_question] Styled answer too long (len={len(styled)}), retrying...")
+                    tailored_attempts += 1
+                    continue
+
+                if validate_styled_answer(agent_name, agent_question, styled, user_profile, processor_llm):
+                    tailored_answer = styled
+                    break
 
-        logging.info("[ask_interview_question] Successfully generated all responses")
-        logging.debug(f"[ask_interview_question] Final responses: {result}")
+                tailored_attempts += 1
+
+            if tailored_answer:
+                responses.append(f"**{agent_name}**: {tailored_answer}")
+            else:
+                responses.append(f"**PreData Moderator**: Failed to stylise the response for {agent_name} after multiple attempts.")
+
+        result = ["\n\n".join(responses)] if len(set(validated_questions.values())) == 1 else responses
 
     except Exception as e:
         logging.exception("[ask_interview_question] Exception occurred during processing")
@@ -582,6 +512,4 @@ def ask_interview_question(respondent_agents_dict, last_active_agent, question,
 
     overall_duration = time.time() - overall_start
     logging.info(f"[ask_interview_question] Completed in {overall_duration:.2f} seconds")
-    logging.info("[ask_interview_question] Exit")
-
     return result