Update researchsimulation/InteractiveInterviewChatbot.py

researchsimulation/InteractiveInterviewChatbot.py

@@ -205,12 +205,6 @@ def validate_question_topics(parsed_questions, processor_llm):
 
     
 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).
-    Uses Groq's LLM for response generation.
-    """
-
     logging.info(f"START: Processing new interview question: {question}")
     responses = []
 
@@ -218,236 +212,120 @@ def ask_interview_question(respondent_agents_dict, last_active_agent, question,
     logging.info(f"Available respondents: {agent_names}")
     print(f"Available respondents: {agent_names}")
 
-    # Use OpenAI LLM to parse questions into individual respondent-specific sub-questions and validate them
-    
-    # Step 1: Parse question
     logging.info("STEP 1: Parsing question with LLM...")
     parsed_questions = parse_question_with_llm(question, str(agent_names), processor_llm)
     logging.info(f"Parsed Questions Output: {parsed_questions}")
-    
+
     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 question content (scope + spelling)
     logging.info("STEP 2: Validating questions for topic relevance and British English...")
     validated_questions = validate_question_topics(parsed_questions, processor_llm)
     logging.info(f"Validated Questions: {validated_questions}")
-    
+
     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."]
 
-    # Use validated questions from this point on
     parsed_questions = validated_questions
-    logging.info(f"Validated questions: {parsed_questions}")  
-        
+
     if len(parsed_questions) > 1:
-        logging.warning("More than one respondent specified. Exiting function.")
-        return "**PreData Moderator**: Please ask each respondent one question at a time."
-    else:
-        print(f"Parsed questions are: {parsed_questions}")
+        return ["**PreData Moderator**: Please ask each respondent one question at a time."]
 
     if "General" in parsed_questions:
-        if "General" in parsed_questions:
-            if isinstance(last_active_agent, list) and all(name in agent_names for name in last_active_agent):
-                logging.info(f"General case detected. Continuing with last active agent: {last_active_agent}")
-                parsed_questions = {name: parsed_questions["General"] for name in last_active_agent}
-            else:
-                logging.info("General case detected without a valid previous active agent. Assigning question to all respondents.")
-                parsed_questions = {name: parsed_questions["General"] for name in agent_names}
+        if isinstance(last_active_agent, list) and all(name in agent_names for name in last_active_agent):
+            parsed_questions = {name: parsed_questions["General"] for name in last_active_agent}
+        else:
+            parsed_questions = {name: parsed_questions["General"] for name in agent_names}
     elif "All" in parsed_questions:
-        logging.info("All case detected. Assigning question to all respondents.")
-        validated_question = parsed_questions["All"]
-        parsed_questions = {name: validated_question for name in agent_names}
-
-
-
+        parsed_questions = {name: parsed_questions["All"] for name in agent_names}
 
     last_active_agent = list(parsed_questions.keys())
-    logging.info(f"Final parsed questions: {parsed_questions}")
-
-    # Construct one crew and task for each agent and question
-    responses = []
 
     for agent_name, agent_question in parsed_questions.items():
         if agent_name not in respondent_agents_dict:
-            logging.warning(f"No valid respondent found for {agent_name}. Skipping.")
             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()
-        
-#        communication_style = user_profile.get_field("Communication", "Style")
-        communication_style = ""
+        user_profile = respondent_agents_dict[agent_name].get_user_profile()
 
-        question_task_description = f"""
-You are {agent_name}. You are responding to a market research interview question. Your response must strictly follow the *style and tone* and *Hard Rules – You Must Follow These Without Exception* outlined below.  
----
-### *Communication Profile Reference:*
-- **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')}
----
----
-### 🔒 **Hard Rules – You Must Follow These Without Exception**
-- You must answer **only the question(s)** that are **explicitly asked**.
-- **Never provide extra information** beyond what was asked.
-- Keep your response **as short as possible** while still sounding natural and complete.
-- Do **not infer or assume** what the user *might* want — only respond to what they *actually* asked.
-- If multiple questions are asked, respond to **each one briefly**, and **nothing else**.
-- If the question is vague, respond minimally and only within that scope.
--Give concise answers, whether the question is asked to the group or individually.
-    -For factual or demographic questions (e.g., age, gender, location, housing), keep responses brief and to the point, without extra commentary.
-        -Do not add any explanations, opinions, or additional information.
-        -Use simple, clear sentences.
-        -Example:
-            Q: Where are you from?
-            A: I’m from [city], [country](DO NOT ADD ANY EXTRA COMMENTS).
-    -For reflective or opinion-based questions (e.g., feelings, preferences, motivations), provide thoughtful but still clear and focused answers. 
-    -Never repeat the question or add unrelated background information.
----
-### **How to Answer:**  
-- Your response should be **natural, authentic, and fully aligned** with the specified style and tone.  
-- Ensure the answer is **clear, engaging, and directly relevant** to the question.  
-- Adapt your **sentence structure, phrasing, and word choices** to match the intended communication style.  
-- If applicable, incorporate **culturally relevant expressions, regional nuances, or industry-specific terminology** that fit the given tone.  
-- **Adjust response length** based on the tone—**concise and direct** for casual styles, **structured and detailed** for professional styles.
-- **Always answer in first person ("I", "my", "me", "mine", etc.) as if you are personally responding to the question. You are an individual representing yourself, not speaking in third person.**
-    -Always answer as if you are the individual being directly spoken to. Use first-person language such as “I,” “me,” “my,” and “mine” in every response. Imagine you are having a real conversation — your tone should feel natural, personal, and authentic. Do not refer to yourself in the third person (e.g., “She is from Trichy” or “Meena likes…”). Avoid describing yourself as if someone else is talking about you. 
-    -Everything you say should come from your own perspective, just like you would in everyday speech. The goal is to sound human, relatable, and direct — like you're truly present in the conversation.
----
-### **Guidelines for Ensuring Authenticity & Alignment:**  
-- **Consistency**: Maintain the same tone throughout the response.  
-- **Authenticity**: The response should feel natural and match the speaker’s persona.  
-- **Avoid Overgeneralisation**: Ensure responses are specific and not overly generic or robotic.  
-- **Cultural & Linguistic Relevance**: Adapt language and references to match the speaker’s background, industry, or region where appropriate.  
-- **Strict British Spelling & Grammar**:  
-  - All responses must use correct British English spelling, grammar, and usage, **irrespective of how the question is phrased**.  
-  - You must not mirror any American spelling, terminology, or phrasing found in the input question.  
-  - Where there are regional variations (e.g. 'licence' vs 'license', 'programme' vs 'program', 'aeroplane' vs 'airplane'), always default to the standard British form.  
-  - Examples:
-    - **Correct (British):** organised, prioritise, minimise, realise, behaviour, centre, defence, travelling, practise (verb), licence (noun), programme, aeroplane.
-    - **Incorrect (American):** organized, prioritize, minimize, realize, behavior, center, defense, traveling, practice (verb and noun), license (noun), program, airplane.
-- **Formatting**:  
-  - If the tone is informal, allow a conversational flow that mirrors natural speech.  
-  - If the tone is formal, use a structured and professional format.  
-- **Do not include emojis or hashtags in the response.**  
-- Maintain **narrative and thematic consistency** across all answers to simulate a coherent personality.
--**Personality Profile Alignment:**
-    -Consider your assigned personality traits across these dimensions:
-        -Big Five Traits:
-            -Openness: Reflect your level of curiosity, creativity, and openness to new experiences
-            -Conscientiousness: Show your degree of organization, responsibility, and planning
-            -Extraversion: Express your sociability and energy level in interactions
-            -Agreeableness: Demonstrate your warmth, cooperation, and consideration for others
-            -Neuroticism: Consider your emotional stability and stress response
-        -Values and Priorities:
-            -Achievement Orientation: Show your drive for success and goal-setting approach
-            -Risk Tolerance: Express your comfort with uncertainty and change
-            -Traditional Values: Reflect your adherence to conventional norms and practices
-        -Communication Style:
-            -Detail Orientation: Demonstrate your preference for specific vs. general information
-            -Complexity: Show your comfort with nuanced vs. straightforward explanations
-            -Directness: Express your communication as either straightforward or diplomatic
-            -Emotional Expressiveness: Reflect your tendency to share or withhold emotions
-    -Your responses must consistently align with these personality traits from your profile.
----
-### **Example Responses (for Different Styles & Tones)**  
-#### **Casual & Conversational Tone**  
-**Question:** "How do you stay updated on the latest fashion and tech trends?"  
-**Correct Response:**  
-"I keep up with trends by following influencers on Instagram and watching product reviews on YouTube. Brands like Noise and Boat always drop stylish, affordable options, so I make sure to stay ahead of the curve."  
-#### **Formal & Professional Tone**  
-**Question:** "How do you stay updated on the latest fashion and tech trends?"  
-**Correct Response:**  
-"I actively follow industry trends by reading reports, attending webinars, and engaging with thought leaders on LinkedIn. I also keep up with global fashion and technology updates through leading publications such as *The Business of Fashion* and *TechCrunch*."  
----
-Your final answer should be **a well-structured response that directly answers the question while maintaining the specified style and tone**:  
-**"{agent_question}"**  
-        """
+        # Step 1: Generate raw answer
+        raw_answer = generate_generic_answer(agent_name, agent_question, respondent_agent)
+        if not raw_answer:
+            responses.append(f"**PreData Moderator**: Could not generate a response for {agent_name}.")
+            continue
 
-        question_task_expected_output = f"""
-A culturally authentic and conversational response to the question: '{agent_question}'.  
-- The response must reflect the respondent's **local cultural background and geographic influences**, ensuring it aligns with their **speech patterns, preferences, and linguistic style**.  
-- The language must follow **strict British English spelling conventions**, ensuring it is **natural, personal, and free-flowing**, while strictly avoiding American spelling, phrasing, or grammar under any circumstances, regardless of the spelling, grammar, or vocabulary used in the input question. 
-- The response **must not introduce the respondent**, nor include placeholders like "[Your Name]" or "[Brand Name]".
-- The response **must always be written in first person ("I", "my", "me", etc.) as if the respondent is personally answering the question directly. Third-person narration is never allowed.**
-- The final output should be a **single, well-structured paragraph that directly answers the question** while staying fully aligned with the specified communication style.  
-        """
-       
-        question_task = Task(
-            description=question_task_description,
-            expected_output=question_task_expected_output,
-            agent=respondent_agent
-        )
-    
-        logging.debug(f"Created task for agent '{agent_name}' with description: {question_task_description}")
-        
-        # Log before starting task execution
-        logging.info(f"Executing task for agent '{agent_name}'")
-        
-        # Create a new crew for each agent-question pair
-        crew = Crew(
-            agents=[respondent_agent],
-            tasks=[question_task],
-            process=Process.sequential
-        )
-        logging.debug(f"Crew initialized for agent '{agent_name}' with 1 task and sequential process")
-        
-        max_attempts = 3
-        attempt = 0
-        validated = False
-        validated_answer = None
-        while attempt < max_attempts and not validated:
-            try:
-                logging.info(f"Starting Response validation attempt {attempt+1} for agent '{agent_name}'")
-                crew_output = crew.kickoff()
-                logging.info(f"Task execution completed for agent '{agent_name}' (attempt {attempt+1})")
-                task_output = question_task.output
-                logging.debug(f"Raw output from agent '{agent_name}': {getattr(task_output, 'raw', str(task_output))}")
-                answer = task_output.raw if hasattr(task_output, 'raw') else str(task_output)
-                logging.info(f"Validating response for agent '{agent_name}' (attempt {attempt+1}): {answer}")
-                # Validate the response using validate_response from validation_utils
-                is_valid = validate_response(
-                    question=agent_question,
-                    answer=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"Response Validation result for agent '{agent_name}' (attempt {attempt+1}): {is_valid}")
-                if is_valid:
-                    validated = True
-                    validated_answer = answer
-                    logging.info(f"Response for agent '{agent_name}' passed validation on attempt {attempt+1}")
-                    break
-                else:
-                    attempt += 1
-                    logging.warning(f"Response failed response validation for agent '{agent_name}' (attempt {attempt}). Retrying...")
-            except Exception as e:
-                logging.error(f"Error during task execution for agent '{agent_name}' (attempt {attempt+1}): {str(e)}", exc_info=True)
-                attempt += 1
-        # --- End validation and retry loop ---
-
-        if validated_answer:
-            formatted_response = f"**{agent_name}**: {validated_answer}"
-            responses.append(formatted_response)
-            logging.info(f"Validated response from agent '{agent_name}' added to responses")
+        # Step 2: Style the answer
+        styled_answer = apply_style_and_tone(raw_answer, user_profile, processor_llm)
+
+        # Step 3: Validate the final answer
+        if validate_answer(styled_answer, agent_question, user_profile, processor_llm):
+            responses.append(f"**{agent_name}**: {styled_answer}")
         else:
-            fallback_response = f"**PreData Moderator**: Unable to pass validation after {max_attempts} attempts for {agent_name}."
-            responses.append(fallback_response)
-            logging.warning(f"No validated output from agent '{agent_name}' after {max_attempts} attempts. Added fallback response.")
-    logging.info(f"All responses generated: {responses}")
+            responses.append(f"**PreData Moderator**: Unable to pass validation for {agent_name}.")
 
     if len(set(parsed_questions.values())) == 1:
-        combined_output = "\n\n".join(responses)
-        return [combined_output]
+        return ["\n\n".join(responses)]
     else:
         return responses
+
+
+def generate_generic_answer(agent_name, question, agent):
+    try:
+        description = f"""You are {agent_name}. Provide a brief, first-person response to: "{question}".
+Use British English. Respond directly and concisely without any extra context or repetition."""
+        expected_output = f"A direct, culturally natural answer to '{question}', written in first person and British English."
+
+        task = Task(description=description, expected_output=expected_output, agent=agent)
+        crew = Crew(agents=[agent], tasks=[task], process=Process.sequential)
+        crew.kickoff()
+
+        output = task.output
+        return output.raw if hasattr(output, 'raw') else str(output)
+    except Exception as e:
+        logging.error(f"Error generating answer for {agent_name}: {e}", exc_info=True)
+        return None
+
+
+def apply_style_and_tone(raw_answer, user_profile, processor_llm):
+    style = user_profile.get_field("Communication", "Style")
+    tone = user_profile.get_field("Communication", "Tone")
+    length = user_profile.get_field("Communication", "Length")
+
+    prompt = f"""
+Transform the following answer to align with the specified communication profile.
+- Style: {style}
+- Tone: {tone}
+- Length: {length}
+- Use strictly British English
+- Maintain first-person voice
+- Keep the cultural authenticity intact
+---
+Answer: "{raw_answer}"
+---
+Transformed Answer:"""
+
+    try:
+        styled_response = processor_llm(prompt)
+        return styled_response.strip()
+    except Exception as e:
+        logging.error(f"Error applying style and tone: {e}", exc_info=True)
+        return raw_answer  # fallback to unstyled answer
+
+
+def validate_answer(answer, question, user_profile, processor_llm):
+    try:
+        return validate_response(
+            question=question,
+            answer=answer,
+            user_profile_str=str(user_profile),
+            fast_facts_str="",
+            interview_transcript_text="",
+            respondent_type="",
+            ai_evaluator_agent=None,
+            processor_llm=processor_llm
+        )
+    except Exception as e:
+        logging.error(f"Validation failed: {e}", exc_info=True)
+        return False