final working demo fix

app.py

@@ -1,109 +1,105 @@
 import gradio as gr
 from src.graph import build_graph
 
-# Initialize the graph
+# Initialize the graph, which is stateless and operates on the state dict we provide.
 graph = build_graph()
 
-class InterviewSession:
-    def __init__(self):
-        """Initializes a new, clean interview state."""
-        self.state = {
-            "interview_status": 0,      # 0: Not started, 1: In progress, 2: Finished/Terminated
-            "interview_history": [],    # Flat list of (role, content) tuples
-            "questions": [],
-            "question_index": 0,
-            "evaluations": [],
-            "final_feedback": "",
-            "warnings": []
-        }
-        print("--- New Interview Session Initialized ---")
-
-    def run(self, user_input):
-        """
-        Main chat function that handles the interview flow.
-        It now returns only the new bot messages for the current turn as a single string.
-        """
-        history_len_before = len(self.state["interview_history"])
-
-        # If this is the very first interaction, start the interview
-        if self.state["interview_status"] == 0:
-            print("Starting interview...")
-            self.state = graph.invoke(self.state)
-        
-        # If there is user input, process it
-        elif user_input and user_input.strip():
-            print(f"Processing user input...")
-            # Add user input to state history
-            self.state["interview_history"].append(("user", user_input))
-            # Process the user response through the graph
-            self.state = graph.invoke(self.state)
-        
-        # Get all new messages added by the graph in this turn
-        new_messages = self.state["interview_history"][history_len_before:]
-        
-        # Extract the content of the new assistant messages
-        response_texts = [content for role, content in new_messages if role != "user"]
-        
-        # Combine new messages into a single response string for Gradio
-        return "\n\n".join(response_texts)
-
-    def reset_interview(self):
-        """Resets the interview session to start over."""
-        print("--- Resetting interview session... ---")
-        self.__init__()
-        # Return an empty list to clear the chatbot display in Gradio
-        return []
-
-# --- Gradio UI Setup ---
-
-# Create a single global session instance
-session = InterviewSession()
-
-def chat_fn(message, history):
+def chat_fn(message: str, history: list[dict[str, str]]):
     """
-    Chat function for Gradio ChatInterface.
-    'history' is managed by Gradio. We use our own session state.
+    Main chat function for Gradio. It is now self-contained and uses the provided
+    history as the source of truth for the conversation state.
+
+    Args:
+        message: The new message from the user.
+        history: The entire conversation history in Gradio's format.
     """
-    return session.run(message)
+    # 1. Convert Gradio's history (list of dicts) to the graph's expected
+    #    internal format (list of tuples).
+    internal_history = []
+    for turn in history:
+        internal_history.append((turn["role"], turn["content"]))
 
-def clear_fn():
-    """Clear function to reset the interview session and the UI."""
-    return session.reset_interview()
+    # 2. Determine the current state based on the history.
+    #    - How many questions have been asked by the assistant?
+    question_count = sum(1 for role, content in internal_history if content in EXCEL_QUESTIONS)
+    
+    #    - Is the interview over?
+    interview_status = 2 if any("interview will now be terminated" in msg[1] for msg in internal_history) or any("performance summary" in msg[1].lower() for msg in internal_history) else 1
+    
+    # 3. Build the state dictionary to pass to the graph on every turn.
+    #    This makes our function stateless, avoiding session-related bugs.
+    current_state = {
+        "interview_status": 0 if not internal_history else interview_status,
+        "interview_history": internal_history,
+        "questions": EXCEL_QUESTIONS, # Assuming EXCEL_QUESTIONS is accessible
+        "question_index": question_count,
+        "evaluations": [], # Note: This simple state doesn't persist evaluations across turns. A more robust solution might need to parse them from history.
+        "final_feedback": "",
+        "warnings": []
+    }
 
-# Use gr.Blocks for more control over the layout and components
-with gr.Blocks(theme="soft", css=".gradio-container {max-width: 1200px; margin: 0 auto;}") as demo:
-    gr.Markdown(
-        """
-        # 🤖 AI-Powered Excel Interviewer (Phi-3 Mini)
-        An AI-powered interview system that asks Excel-related questions and provides feedback. 
-        The system includes AI-generated response detection to ensure authentic answers.
-        """
-    )
+    # Add the user's new message to the history for the graph to process
+    current_state["interview_history"].append(("user", message))
     
-    chatbot = gr.Chatbot(
-        elem_id="chatbot",
-        label="Interview Conversation",
+    # 4. Invoke the graph with the current state.
+    print(f"Invoking graph with question index: {current_state['question_index']}")
+    new_state = graph.invoke(current_state)
+    
+    # 5. Convert the graph's output history back to Gradio's format.
+    #    The graph returns the *complete* new history.
+    gradio_history = []
+    for role, content in new_state["interview_history"]:
+        if role in ["user", "assistant", "ai"]: # Handle 'ai' as 'assistant'
+            gradio_history.append({"role": "assistant" if role == "ai" else role, "content": content})
+            
+    return gradio_history
+
+# This list must be accessible to the chat function.
+# It's better to define it here or import it from a shared config.
+EXCEL_QUESTIONS = [
+    "What is the difference between the VLOOKUP and HLOOKUP functions in Excel?",
+    "Explain how to use the INDEX and MATCH functions together, and why you might prefer them over VLOOKUP.",
+    "Describe what a Pivot Table is and give an example of a scenario where it would be useful.",
+    "What is Conditional Formatting in Excel? Can you provide an example?",
+]
+
+# Create the ChatInterface. No separate clear function is needed if we don't have a session.
+# The 'Clear' button is built-in and will correctly clear the UI.
+demo = gr.ChatInterface(
+    fn=chat_fn,
+    title="🤖 AI-Powered Excel Interviewer (Phi-3 Mini)",
+    description="An AI-powered interview system that asks Excel-related questions and provides feedback. Click one of the examples or type a message like 'start' to begin.",
+    chatbot=gr.Chatbot(
         show_copy_button=True,
         height=600,
-        avatar_images=(None, "https://upload.wikimedia.org/wikipedia/commons/1/1d/Microsoft_Excel_2013-2019_logo.svg"),
-        bubble_full_width=False,
-        placeholder="Click the 'Start Interview' button below to begin."
-    )
-
-    # Use gr.ChatInterface as a component within gr.Blocks
-    # We will hide its internal textbox and use our own for better control.
-    interface = gr.ChatInterface(
-        fn=chat_fn,
-        chatbot=chatbot,
-        submit_btn="Submit Answer",
-        retry_btn=None,
-        undo_btn=None,
-    )
-    
-    # Custom clear button that correctly resets the session state
-    clear_button = gr.Button("Clear and Restart Interview", variant="stop")
-    clear_button.click(fn=clear_fn, inputs=[], outputs=[chatbot], queue=False)
+        placeholder="The interview will begin after you send your first message."
+    ),
+    textbox=gr.Textbox(
+        placeholder="Type your answer here and press Enter...", 
+        label="Your Response",
+        lines=3
+    ),
+    theme="soft",
+    submit_btn="Submit Answer",
+    examples=[ # These examples now work as intended.
+        "I'm ready to start the interview",
+        "Let's begin",
+        "Start the assessment"
+    ],
+    cache_examples=False
+)
 
+# Add custom CSS for better styling
+demo.css = """
+    .chat-message {
+        font-size: 16px;
+        line-height: 1.5;
+    }
+    .gradio-container {
+        max-width: 1200px;
+        margin: 0 auto;
+    }
+"""
 
 if __name__ == "__main__":
     demo.launch(

src/interview_logic.py

@@ -1,6 +1,5 @@
 # src/interview_logic.py
 
-# No more external LLM libraries needed here!
 from .perplexity_detector import is_ai_generated
 from .local_llm_handler import get_llm_response
 
@@ -11,19 +10,28 @@ EXCEL_QUESTIONS = [
     "What is Conditional Formatting in Excel? Can you provide an example?",
 ]
 
+# --- CORRECTED FUNCTION ---
 def start_interview(state: dict) -> dict:
-    intro_message = "Welcome to the automated Excel skills assessment..."
-    current_question = EXCEL_QUESTIONS[0]
+    """
+    This function now ONLY adds a welcome message. It APPENDS to the history,
+    preserving the user's first message. The graph will then transition to 'ask_question'
+    to ask the first question.
+    """
+    intro_message = "Welcome to the automated Excel skills assessment! I will ask you a series of questions to gauge your knowledge. Let's start with the first one."
+    
+    # Get the existing history from the state
+    history = state.get("interview_history", [])
+    
+    # Append the welcome message
+    history.append(("ai", intro_message))
 
+    # Return the updated state. We do NOT ask a question here.
     return {
         **state,
         "interview_status": 1,
-        "interview_history": [
-            ("ai", intro_message),
-            ("ai", current_question)
-        ],
+        "interview_history": history, # Use the modified history
         "questions": EXCEL_QUESTIONS,
-        "question_index": 0,
+        "question_index": 0, # Ensure index starts at 0 for the first question
         "evaluations": [],
         "warnings": [],
         "final_feedback": "",
@@ -31,28 +39,31 @@ def start_interview(state: dict) -> dict:
 
 
 def ask_question(state: dict) -> dict:
+    """
+    This function is now responsible for asking ALL questions, including the first one.
+    It remains unchanged but its role is now clearer.
+    """
     question_index = state["question_index"]
     current_question = state["questions"][question_index]
     
     history = state.get("interview_history", [])
-    history.append(("ai", current_question))  # append as a separate entry
+    history.append(("ai", current_question))
     
     return { **state, "interview_history": history }
 
 
-# --- MODIFIED FUNCTION ---
 def process_user_response(state: dict) -> dict:
+    """This function remains unchanged."""
     history = state.get("interview_history", [])
     user_response = history[-1][1]
 
     if is_ai_generated(user_response, threshold=35.0):
-        termination_message = "This interview will now be terminated..."
+        termination_message = "This interview will now be terminated due to the detection of AI-generated content."
         history.append(("ai", termination_message))
         return {**state, "interview_history": history, "interview_status": 2}
     
     current_question = state["questions"][state["question_index"]]
 
-    # Create the prompt manually for our local LLM
     evaluation_prompt = (
         "You are an expert evaluator. Concisely evaluate the following answer to an Excel interview question "
         "based on its technical accuracy and clarity. Start the evaluation directly without conversational filler.\n\n"
@@ -60,38 +71,59 @@ def process_user_response(state: dict) -> dict:
         f"Answer: {user_response}"
     )
     
-    # Get the evaluation from our new local LLM handler
     evaluation = get_llm_response(evaluation_prompt)
     
+    # Prepend the evaluation with a clear marker for the user
+    history.append(("ai", f"**Evaluation:**\n{evaluation}"))
+    
     evaluations = state.get("evaluations", [])
     evaluations.append(evaluation)
 
-    return {**state, "evaluations": evaluations, "question_index": state["question_index"] + 1}
+    # Increment the question index for the next turn
+    return {
+        **state, 
+        "interview_history": history,
+        "evaluations": evaluations, 
+        "question_index": state["question_index"] + 1
+    }
 
 def generate_final_report(state: dict) -> dict:
+    """This function remains unchanged."""
     interview_transcript = "\n".join([f"{speaker.capitalize()}: {text}" for speaker, text in state['interview_history']])
     evaluations_summary = "\n\n".join(f"Evaluation for Q{i+1}:\n{e}" for i, e in enumerate(state['evaluations']))
 
-    # Create the report prompt manually
     report_prompt = (
         "You are a career coach. Based on the interview transcript and evaluations below, write a brief, constructive performance summary. "
         "Use Markdown for a 'Strengths' section and an 'Areas for Improvement' section.\n\n"
         f"---TRANSCRIPT---\n{interview_transcript}\n\n---EVALUATIONS---\n{evaluations_summary}"
     )
     
-    # Get the report from our local LLM handler
     final_feedback = get_llm_response(report_prompt)
 
     history = state.get("interview_history", [])
-    history.append(("ai", final_feedback))
+    history.append(("ai", f"**Final Performance Summary:**\n{final_feedback}"))
 
     return {**state, "final_feedback": final_feedback, "interview_history": history, "interview_status": 2}
 
-# Routing logic does not need to change
+
+# --- CORRECTED ROUTING ---
+# The routing logic itself is fine, but its behavior is now correct because
+# the nodes it routes to have been fixed.
+
 def route_after_evaluation(state: dict):
-    if state.get("interview_status") == 2: return "terminate"
-    elif state["question_index"] >= len(state["questions"]): return "generate_final_report"
-    else: return "ask_question"
+    if state.get("interview_status") == 2:
+        return "terminate"
+    # The evaluation node now just adds feedback, so we check the index to see if we should ask another question or end.
+    elif state["question_index"] >= len(state["questions"]):
+        return "generate_final_report"
+    else:
+        return "ask_question"
 
 def route_start_of_interview(state: dict):
-    return "start_interview" if state.get("interview_status", 0) == 0 else "process_user_response"
+    # This logic is now correct. If history is empty, the status is 0.
+    # The app.py will add the first user message, making the history non-empty,
+    # so the graph will correctly call start_interview.
+    if not state.get("interview_history"):
+        return "start_interview"
+    else:
+        return "process_user_response"