Upload 26 files

.env

@@ -0,0 +1 @@
+OPENAI_API_KEY=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

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

README.md

@@ -1,12 +1,36 @@
----
-title: Version1
-emoji: 🔥
-colorFrom: gray
-colorTo: indigo
-sdk: gradio
-sdk_version: 6.3.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: AI Teacher Bot
+emoji: 🧠
+colorFrom: blue
+colorTo: green
+sdk: gradio
+sdk_version: "3.44"
+app_file: app.py
+pinned: true
+---
+
+# AI Teacher Bot
+
+**Interactive Personalized Learning Platform**
+
+AI Teacher Bot is an interactive learning platform that:
+- Teaches modules with detailed explanations adapted to the user's learning level (Novice, Intermediate, Advanced)
+- Evaluates student examples and provides constructive feedback
+- Performs Bloom’s Taxonomy assessments per chapter to measure understanding
+- Generates structured, level-appropriate curriculum automatically
+
+**Usage**
+1. Enter a topic and select your claimed level.
+2. Click “Start Session” to begin learning.
+3. Follow module explanations and submit examples.
+4. Complete Bloom assessments to evaluate mastery.
+
+**Tech Stack**
+- Python 3.12
+- Gradio (for UI)
+- OpenAI API (GPT-4o-mini)
+
+**Notes**
+- Ensure you have a valid OpenAI API key set in `.env`.
+- For testing and temporary deployment, Gradio provides shareable links.
+- For permanent hosting, this app runs on Hugging Face Spaces.

agents/base_agent.py

@@ -0,0 +1,6 @@
+class BaseAgent:
+    def __init__(self, name):
+        self.name = name
+
+    def process(self, *args, **kwargs):
+        raise NotImplementedError("Each agent must implement the process method.")

agents/bloom_assess.py

@@ -0,0 +1,218 @@
+import os
+from dotenv import load_dotenv
+import openai
+import json
+from .base_agent import BaseAgent
+
+load_dotenv()
+
+class BloomsAssessmentAgent(BaseAgent):
+    def __init__(self):
+        super().__init__("BloomsAssessmentAgent")
+        api_key = os.getenv("OPENAI_API_KEY")
+        self.client = openai.OpenAI(api_key=api_key)
+        self.bloom_levels = [
+            "Remembering", "Understanding", "Applying", 
+            "Analyzing", "Evaluating", "Creating"
+        ]
+
+    def generate_bloom_question(self, chapter, bloom_level):
+        system_prompt = (
+            f"You are an expert educator creating a {bloom_level} level question according to Bloom's Taxonomy. "
+            f"Generate ONE question that tests the student's ability at the {bloom_level} level for the given chapter. "
+            "The question should be clear, concise, and appropriate for the chapter content. "
+            "Return ONLY the question text, no additional formatting or explanation."
+        )
+        
+        user_prompt = (
+            f"Chapter: {chapter.name}\n"
+            f"Modules in this chapter: {[m.name for m in chapter.modules]}\n"
+            f"Bloom's Level: {bloom_level}\n"
+            f"Generate a {bloom_level} level question."
+        )
+        
+        response = self.client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt}
+            ]
+        )
+        return response.choices[0].message.content.strip()
+
+    def evaluate_bloom_answer(self, question, user_answer, bloom_level, chapter):
+        system_prompt = (
+            f"You are an expert educator evaluating a student's answer for a {bloom_level} level question. "
+            "Evaluate the answer based on the specific cognitive skills required for this Bloom's level. "
+            "Be STRICT about answer quality - vague, incomplete, or overly brief answers should receive low scores.\n\n"
+            "**Evaluation Criteria:**\n"
+            "- **Precision:** Is the answer specific and detailed enough for the Bloom's level?\n"
+            "- **Relevance:** Does it directly address the question asked?\n"
+            "- **Depth:** Does it demonstrate the expected cognitive complexity?\n"
+            "- **Completeness:** Are all parts of the question addressed?\n\n"
+            "**Automatic Penalties:**\n"
+            "- Answers under 15 words: Maximum score of 3\n"
+            "- Vague responses (yes/no, maybe, I think): Maximum score of 2\n"
+            "- Off-topic or irrelevant answers: Score of 0-1\n\n"
+            "You must respond with a JSON object containing:\n"
+            "1. 'score': A number between 0 and 10\n"
+            "2. 'feedback': Detailed explanation of the score and what was missing\n"
+            "3. 'level_achieved': The Bloom's level the answer demonstrates\n"
+            "4. 'hint': A subtle hint to guide toward better understanding (if score < 7)"
+        )
+        
+        user_prompt = (
+            f"Question (Bloom's Level: {bloom_level}): {question}\n"
+            f"Student's Answer: {user_answer}\n"
+            f"Chapter Context: {chapter.name}\n"
+            "Evaluate this answer and provide the JSON response."
+        )
+        
+        response = self.client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt}
+            ]
+        )
+        return response.choices[0].message.content.strip()
+
+    def process(self, chapter):
+        print(f"\n{'='*60}")
+        print(f"BLOOM'S TAXONOMY ASSESSMENT")
+        print(f"Chapter: {chapter.name}")
+        print(f"{'='*60}")
+        print("You will be asked 2 questions for each of the 6 Bloom's levels.")
+        print("This comprehensive assessment will evaluate your mastery of the chapter.")
+        
+        results = {}
+        total_score = 0
+        questions_asked = 0
+        
+        for bloom_level in self.bloom_levels:
+            level_scores = []
+            print(f"\n--- {bloom_level.upper()} LEVEL (2 Questions) ---")
+            
+            for question_num in range(1, 3):  # 2 questions per level
+                print(f"\n[Question {question_num}/2 for {bloom_level}]")
+                
+                question = self.generate_bloom_question(chapter, bloom_level)
+                print(f"Question: {question}")
+                
+                user_answer = input("Your answer: ")
+                
+                evaluation_json = self.evaluate_bloom_answer(question, user_answer, bloom_level, chapter)
+                
+                try:
+                    evaluation = json.loads(evaluation_json)
+                    score = evaluation.get('score', 0)
+                    feedback = evaluation.get('feedback', 'No feedback provided')
+                    level_achieved = evaluation.get('level_achieved', bloom_level)
+                    hint = evaluation.get('hint', '')
+                    
+                    print(f"Score: {score}/10")
+                    print(f"Feedback: {feedback}")
+                    print(f"Level Demonstrated: {level_achieved}")
+                    
+                    # If score is low, provide hint and offer retry
+                    if score < 7 and hint:
+                        print(f"💡 Hint: {hint}")
+                        
+                        retry = input("\nYour answer needs improvement. Would you like to try again? (y/n): ").lower().strip()
+                        if retry == 'y':
+                            print("\n🔄 Please provide a more detailed and specific answer.")
+                            retry_answer = input("Your revised answer: ")
+                            
+                            # Re-evaluate the retry answer
+                            retry_evaluation_json = self.evaluate_bloom_answer(question, retry_answer, bloom_level, chapter)
+                            try:
+                                retry_evaluation = json.loads(retry_evaluation_json)
+                                retry_score = retry_evaluation.get('score', 0)
+                                retry_feedback = retry_evaluation.get('feedback', 'No feedback provided')
+                                retry_level = retry_evaluation.get('level_achieved', bloom_level)
+                                
+                                print(f"\nRetry Score: {retry_score}/10")
+                                print(f"Retry Feedback: {retry_feedback}")
+                                print(f"Retry Level Demonstrated: {retry_level}")
+                                
+                                # Use the better of the two scores
+                                final_score = max(score, retry_score)
+                                level_scores.append(final_score)
+                                total_score += final_score
+                                questions_asked += 1
+                                
+                            except json.JSONDecodeError:
+                                print("Error evaluating retry answer. Using original score.")
+                                level_scores.append(score)
+                                total_score += score
+                                questions_asked += 1
+                        else:
+                            level_scores.append(score)
+                            total_score += score
+                            questions_asked += 1
+                    else:
+                        level_scores.append(score)
+                        total_score += score
+                        questions_asked += 1
+                    
+                except json.JSONDecodeError:
+                    print("Error evaluating answer. Defaulting to score 5.")
+                    level_scores.append(5)
+                    total_score += 5
+                    questions_asked += 1
+            
+            # Store results for this Bloom's level
+            results[bloom_level] = {
+                'scores': level_scores,
+                'average_score': sum(level_scores) / len(level_scores),
+                'total_score': sum(level_scores)
+            }
+        
+        # Calculate overall results
+        max_possible = questions_asked * 10
+        average_score = total_score / questions_asked
+        percentage = (total_score / max_possible) * 100
+        
+        print(f"\n{'='*60}")
+        print("COMPREHENSIVE ASSESSMENT RESULTS")
+        print(f"{'='*60}")
+        print(f"Total Score: {total_score}/{max_possible}")
+        print(f"Average Score: {average_score:.1f}/10")
+        print(f"Percentage: {percentage:.1f}%")
+        
+        # Enhanced mastery determination
+        if percentage >= 85:
+            mastery = "Excellent Mastery"
+            recommendation = "Ready to advance to next level"
+        elif percentage >= 70:
+            mastery = "Good Understanding"
+            recommendation = "Ready to advance with some review"
+        elif percentage >= 55:
+            mastery = "Basic Understanding"
+            recommendation = "Review weak areas before advancing"
+        else:
+            mastery = "Needs Significant Review"
+            recommendation = "Revisit chapter content and retake assessment"
+        
+        print(f"Mastery Level: {mastery}")
+        print(f"Recommendation: {recommendation}")
+        
+        print(f"\nDetailed Breakdown by Bloom's Level:")
+        for level, result in results.items():
+            avg = result['average_score']
+            print(f"  {level}: {avg:.1f}/10 (Scores: {result['scores']})")
+        
+        # Determine if student should advance or review
+        should_advance = percentage >= 70
+        
+        return {
+            'chapter': chapter.name,
+            'total_score': total_score,
+            'max_possible': max_possible,
+            'average_score': average_score,
+            'percentage': percentage,
+            'mastery_level': mastery,
+            'recommendation': recommendation,
+            'should_advance': should_advance,
+            'detailed_results': results
+        }

agents/coordinator.py

@@ -0,0 +1,106 @@
+from .base_agent import BaseAgent
+from .teacher import NoviceTeacherAgent, IntermediateTeacherAgent, AdvancedTeacherAgent
+from .bloom_assess import BloomsAssessmentAgent
+from curriculum import Chapter, Module
+
+class CoordinatorAgent(BaseAgent):
+    def __init__(self, user_level, user_state):
+        super().__init__("CoordinatorAgent")
+        if user_level == "novice":
+            self.teacher = NoviceTeacherAgent()
+        elif user_level == "intermediate":
+            self.teacher = IntermediateTeacherAgent()
+        else:
+            self.teacher = AdvancedTeacherAgent()
+        
+        self.bloom_assessor = BloomsAssessmentAgent()
+        self.user_state = user_state
+
+    def teach_curriculum(self, curriculum):
+        print("\n[System] Starting the teaching session!")
+        print(self.user_state.get_progress_summary(curriculum))
+        
+        for chapter_idx, chapter in enumerate(curriculum.chapters, 1):
+            print(f"\n{'='*60}")
+            print(f"CHAPTER {chapter_idx}: {chapter.name}")
+            print(f"{'='*60}")
+            
+            # Teach all modules in the chapter
+            for module_idx, module in enumerate(chapter.modules, 1):
+                while True:
+                    print(f"\n--- Module {chapter_idx}.{module_idx}: {module.name} ---")
+                    # Display the teaching content
+                    explanation = self.teacher.teach_module(module)
+                    print(f"\n📚 {explanation}")
+                    if self.teacher.check_example(module):
+                        print("[System] Good job! Moving to next module.")
+                        # Update progress
+                        self.user_state.update_module_progress(chapter.name, module.name, "completed")
+                        break
+                    else:
+                        print("[System] Let's review this module again.")
+                        self.user_state.update_module_progress(chapter.name, module.name, "reviewed")
+            
+            # Chapter completed - run Bloom's assessment
+            print(f"\n[System] Chapter '{chapter.name}' completed! Time for a comprehensive assessment.")
+            assessment_results = self.bloom_assessor.process(chapter)
+            
+            # Check if student should advance or review based on Bloom's assessment
+            should_advance = assessment_results.get('should_advance', False)
+            percentage = assessment_results.get('percentage', 0)
+            
+            if should_advance:
+                print(f"\n🎉 Excellent work! You scored {percentage:.1f}% and demonstrated mastery.")
+                print("✅ You're ready to advance to the next chapter!")
+                
+                # Update progress with assessment results
+                self.user_state.update_bloom_assessment(chapter.name, assessment_results)
+                self.user_state.update_chapter_progress(chapter.name, "completed")
+                
+                # Show updated progress
+                print("\n" + self.user_state.get_progress_summary(curriculum))
+                
+                # Ask if user wants to continue
+                if chapter_idx < len(curriculum.chapters):
+                    continue_choice = input("\nContinue to next chapter? (y/n): ").lower().strip()
+                    if continue_choice != 'y':
+                        print("[System] Progress updated. You can resume later.")
+                        return
+                else:
+                    print(f"\n{'='*60}")
+                    print("CONGRATULATIONS!")
+                    print(f"{'='*60}")
+                    print("You have completed the entire curriculum!")
+                    print(self.user_state.get_progress_summary(curriculum))
+            else:
+                print(f"\n📚 You scored {percentage:.1f}% on the assessment.")
+                print("🔄 Based on your performance, let's review this chapter to strengthen your understanding.")
+                
+                # Update progress but mark chapter as needing review
+                self.user_state.update_bloom_assessment(chapter.name, assessment_results)
+                self.user_state.update_chapter_progress(chapter.name, "needs_review")
+                
+                # Ask if user wants to retake the chapter or continue anyway
+                review_choice = input("\nWould you like to:\n1. Review this chapter again (r)\n2. Continue to next chapter anyway (c)\n3. Save progress and exit (s)\nChoice: ").lower().strip()
+                
+                if review_choice == 'r':
+                    print(f"\n🔄 Let's review Chapter {chapter_idx}: {chapter.name}")
+                    # Restart the chapter
+                    chapter_idx -= 1  # Will be incremented at the end of the loop
+                elif review_choice == 'c':
+                    print("⚠️  Continuing to next chapter. Consider reviewing weak areas later.")
+                    if chapter_idx < len(curriculum.chapters):
+                        continue_choice = input("\nContinue to next chapter? (y/n): ").lower().strip()
+                        if continue_choice != 'y':
+                            print("[System] Progress updated. You can resume later.")
+                            return
+                    else:
+                        print(f"\n{'='*60}")
+                        print("CURRICULUM COMPLETED!")
+                        print(f"{'='*60}")
+                        print("You have completed the entire curriculum!")
+                        print("Note: Some chapters may need review for better mastery.")
+                        print(self.user_state.get_progress_summary(curriculum))
+                else:  # exit
+                    print("[System] Progress updated. You can resume later.")
+                    return

agents/curriculum_planner.py

@@ -0,0 +1,88 @@
+import os
+from dotenv import load_dotenv
+import openai
+import json
+import re
+from .base_agent import BaseAgent
+from curriculum import Curriculum, Chapter, Module
+
+class CurriculumPlannerAgent(BaseAgent):
+    def __init__(self):
+        super().__init__("CurriculumPlannerAgent")
+        load_dotenv()
+        api_key = os.getenv("OPENAI_API_KEY")
+        self.client = openai.OpenAI(api_key=api_key)
+
+    def process(self, topic, level):
+        system_prompt = (
+            "You are an Expert Instructional Architect. Design a detailed, academically rigorous curriculum.\n\n"
+
+            "### Rules:\n"
+            "1. Ensure academic depth and avoid trivial content.\n"
+            "2. Respect the level:\n"
+            "- Novice: fundamentals, 4–6 modules per chapter.\n"
+            "- Intermediate: problem-solving & applications, 5–7 modules per chapter.\n"
+            "- Advanced: theory, research, edge cases, 6–8 modules per chapter.\n"
+            "3. Each module must have:\n"
+            "- `module_name`\n"
+            "- `learning_objective` (with knowledge, skills, applications, examples)\n"
+            "4. Use progressive complexity.\n\n"
+
+            "### Example Curriculum (Novice, Topic: Python Programming)\n"
+            "{\n"
+            "  \"chapters\": [\n"
+            "    {\n"
+            "      \"chapter_name\": \"Introduction to Python\",\n"
+            "      \"modules\": [\n"
+            "        {\"module_name\": \"What is Python?\", \"learning_objective\": \"Understand Python’s role as a programming language, its history, and its everyday applications.\"},\n"
+            "        {\"module_name\": \"Setting Up Python\", \"learning_objective\": \"Learn how to install Python and write your first basic script.\"},\n"
+            "        {\"module_name\": \"Variables and Data Types\", \"learning_objective\": \"Understand how to store data in variables and use types such as strings, numbers, and booleans.\"}\n"
+            "      ]\n"
+            "    },\n"
+            "    {\n"
+            "      \"chapter_name\": \"Control Structures\",\n"
+            "      \"modules\": [\n"
+            "        {\"module_name\": \"If Statements\", \"learning_objective\": \"Learn decision-making in programs with if/else statements and simple examples.\"},\n"
+            "        {\"module_name\": \"Loops\", \"learning_objective\": \"Understand repetition using for and while loops with practical use cases.\"}\n"
+            "      ]\n"
+            "    }\n"
+            "  ]\n"
+            "}\n\n"
+
+            "### Instructions:\n"
+            "- Follow the same style for the requested topic.\n"
+            "- Do NOT output explanations outside JSON.\n"
+        )
+
+        user_prompt = f"Generate a curriculum for:\nTopic: {topic}\nLevel: {level}"
+
+        response = self.client.chat.completions.create(
+            model="gpt-4o-mini",
+            response_format={"type": "json_object"},
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt}
+            ]
+        )
+
+        try:
+            curriculum_json = response.choices[0].message.content.strip()
+            match = re.search(r'\{.*\}', curriculum_json, re.DOTALL)
+            if match:
+                json_str = match.group(0)
+            else:
+                raise ValueError("No JSON found in the response")
+
+            chapters_obj = json.loads(json_str)
+            chapters_data = chapters_obj["chapters"]
+
+            chapters = []
+            for ch in chapters_data:
+                modules = [Module(m["module_name"], m["learning_objective"]) for m in ch["modules"]]
+                chapters.append(Chapter(ch["chapter_name"], modules))
+
+            return Curriculum(topic, chapters)
+
+        except Exception as e:
+            print("[CurriculumPlannerAgent] Error parsing curriculum:", e)
+            return Curriculum(topic, [Chapter("General Introduction", [Module("Overview")])])

agents/level_assess.py

@@ -0,0 +1,247 @@
+from .base_agent import BaseAgent
+import os
+import openai
+from dotenv import load_dotenv
+import json
+
+class LevelAssessmentAgent(BaseAgent):
+    def __init__(self):
+        super().__init__("LevelAssessmentAgent")
+        load_dotenv()
+        api_key = os.getenv("OPENAI_API_KEY")
+        self.client = openai.OpenAI(api_key=api_key)
+
+    def generate_questions(self, topic, level):
+        system_prompt = (
+        "You are a Master Educator and Curriculum Designer with deep expertise in pedagogical theory and assessment creation. "
+        "Your primary goal is to design a short, insightful assessment to precisely gauge a student's mastery of a topic at a specific proficiency level.\n\n"
+        "**Your Guiding Principles:**\n\n"
+        "1. **Cognitive Depth:** The questions must go beyond rote memorization. They should probe the student's reasoning, problem-solving abilities, and their ability to connect concepts.\n"
+        "2. **Level-Specific Targeting:** You must strictly adhere to the specified 'level':\n"
+        "    - **Beginner:** Focus on core concepts, definitions, and simple \"how\" or \"why\" explanations. (Testing Comprehension & Application)\n"
+        "    - **Intermediate:** Focus on comparing/contrasting concepts, applying knowledge to simple scenarios, and analyzing processes. (Testing Application & Analysis)\n"
+        "    - **Advanced:** Demand synthesis of multiple concepts, evaluation of complex scenarios, and creation of novel solutions or arguments. (Testing Synthesis & Evaluation)\n"
+        "3. **Clarity and Precision:** Each question must be unambiguous, concise, and clearly worded.\n\n"
+        "**Output Format:**\n"
+        "You must generate exactly 5 to 6 questions. Your response should contain ONLY the numbered list of questions. Do not include a title, introduction, conclusion, or any other text."
+    )
+        
+        user_prompt = (
+            f"Generate a assessment for 5 questions to test if a student is truly at the '{level}' level in the topic '{topic}'. "
+            "The question should be open-ended and require a thoughtful answer."
+        )
+        response  = self.client.chat.completions.create(model = "gpt-4o-mini", 
+                                                      messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt}
+            ]
+        )
+        return response.choices[0].message.content.strip()
+
+    def evaluate_answer(self, topic, level, question, user_answer):
+        system_prompt = (
+    "You are a meticulous and impartial Grader AI. Your task is to evaluate a student's answer based on a provided question and the student's claimed proficiency level. You must adhere to the following STRICT rubric:\n\n"
+    "1.  **Precision Requirement:** The answer must be specific, detailed, and demonstrate clear understanding. Vague, generic, or one-word answers are automatically INCORRECT.\n"
+    "2.  **Correctness:** Is the answer factually accurate and relevant to the question?\n"
+    "3.  **Depth:** Does the answer's depth match the expected level?\n"
+    "    - **Novice/Beginner:** The answer should demonstrate basic comprehension and recall of key concepts with specific examples.\n"
+    "    - **Intermediate:** The answer should show an ability to apply concepts, compare, and analyze with clear reasoning.\n"
+    "    - **Advanced:** The answer must demonstrate synthesis, evaluation, and nuanced understanding with sophisticated insights.\n"
+    "4.  **Completeness:** The answer must address all parts of the question comprehensively.\n\n"
+    "**AUTOMATIC FAILURES:**\n"
+    "- Answers under 20 words are automatically incorrect\n"
+    "- Vague responses like 'yes', 'no', 'it depends', 'I think so', 'maybe', 'probably'\n"
+    "- Responses that don't directly address the specific question asked\n"
+    "- Copy-paste definitions without personal understanding or application\n\n"
+    "You must respond ONLY with a JSON object. Do not include any other text or markdown formatting. The JSON object must have three keys:\n"
+    "1.  `\"evaluation\"`: a string with a value of either `\"correct\"` or `\"incorrect\"`.\n"
+    "2.  `\"reasoning\"`: a detailed explanation for your decision, including what was missing or incorrect.\n"
+    "3.  `\"hint\"`: a subtle hint to guide the student toward the correct answer (only if incorrect)."
+)
+        user_prompt = (
+    f"Evaluate the following data based on the rubric. Provide your response in the required JSON format.\n\n"
+    f"**Topic:** \"{topic}\"\n"
+    f"**Proficiency Level to Evaluate:** \"{level}\"\n"
+    f"**Question:** \"{question}\"\n"
+    f"**Student's Answer:** \"{user_answer}\""
+)
+        response = self.client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt}
+            ]
+        )
+        return response.choices[0].message.content.strip()
+
+    def challenge_feedback(self, topic, level, question, user_answer, original_evaluation, original_reasoning):
+        """
+        Allows a student to challenge the feedback given. Re-evaluates the answer
+        with a focus on being fair and reconsidering the evaluation.
+        Returns a JSON string with the challenge result.
+        """
+        system_prompt = (
+            "You are a fair and reconsidering Grader AI. A student has challenged your previous evaluation. "
+            "Your task is to carefully re-examine the student's answer with fresh eyes, considering that "
+            "your initial evaluation may have been too strict or may have missed valid points.\n\n"
+            "**Re-evaluation Guidelines:**\n"
+            "1. Be open to reconsidering your initial assessment\n"
+            "2. Look for valid points in the answer that may have been overlooked\n"
+            "3. Consider alternative interpretations of the question\n"
+            "4. If the answer demonstrates understanding (even if not perfect), acknowledge it\n"
+            "5. Be fair and balanced in your re-evaluation\n\n"
+            "You must respond ONLY with a JSON object containing:\n"
+            "1. `\"evaluation\"`: either `\"correct\"` or `\"incorrect\"`\n"
+            "2. `\"reasoning\"`: detailed explanation of your re-evaluation, including whether you changed your mind and why\n"
+            "3. `\"original_was_fair\"`: true/false indicating if the original evaluation was fair\n"
+            "4. `\"hint\"`: a hint if still incorrect"
+        )
+        
+        user_prompt = (
+            f"**Topic:** {topic}\n"
+            f"**Proficiency Level:** {level}\n"
+            f"**Question:** {question}\n"
+            f"**Student's Answer:** {user_answer}\n\n"
+            f"**Original Evaluation:** {original_evaluation}\n"
+            f"**Original Reasoning:** {original_reasoning}\n\n"
+            "Please re-evaluate this answer fairly. The student believes the original evaluation may have been incorrect."
+        )
+        
+        response = self.client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt}
+            ]
+        )
+        return response.choices[0].message.content.strip()
+
+    def challenge_discussion(self, topic, level, question, user_answer, original_evaluation, original_reasoning, conversation_history, student_message):
+        """
+        Handles a conversational challenge discussion between student and grader.
+        conversation_history: list of [user_message, assistant_message] pairs
+        student_message: the current student's argument/question
+        Returns: assistant response and final evaluation (if discussion is ending)
+        """
+        system_prompt = (
+            "You are a fair and patient Grader AI engaged in a discussion with a student who is challenging your evaluation. "
+            "You should be open to reconsidering your assessment, but also maintain academic standards.\n\n"
+            "**Your Role:**\n"
+            "1. Listen carefully to the student's arguments\n"
+            "2. Be willing to reconsider if the student makes valid points\n"
+            "3. Explain your reasoning clearly and respectfully\n"
+            "4. If the student is right, acknowledge it and update your evaluation\n"
+            "5. If the student's argument doesn't change your assessment, explain why clearly\n\n"
+            "**Context:**\n"
+            f"- Topic: {topic}\n"
+            f"- Level: {level}\n"
+            f"- Question: {question}\n"
+            f"- Student's Original Answer: {user_answer}\n"
+            f"- Original Evaluation: {original_evaluation}\n"
+            f"- Original Reasoning: {original_reasoning}\n\n"
+            "Respond naturally in a conversational manner. Be helpful and educational, not defensive."
+        )
+        
+        messages = [{"role": "system", "content": system_prompt}]
+        
+        # Add conversation history
+        for user_msg, assistant_msg in conversation_history:
+            messages.append({"role": "user", "content": user_msg})
+            messages.append({"role": "assistant", "content": assistant_msg})
+        
+        # Add current student message
+        messages.append({"role": "user", "content": student_message})
+        
+        response = self.client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=messages
+        )
+        return response.choices[0].message.content.strip()
+
+    def process(self, topic, level):
+        print(f"\n[Assessment] Let's test your knowledge for the '{level}' level in '{topic}'.")
+        print("I will ask you 5 questions.")
+        
+        NUM_QUESTIONS = 5
+        # New scoring thresholds based on your requirements
+        ADVANCED_PASS = 0.70  # 70% for advanced level
+        INTERMEDIATE_PASS = 0.65  # 65% for intermediate level
+        MINIMUM_THRESHOLD = 0.30  # 30% minimum to avoid novice
+
+        all_questions_str = self.generate_questions(topic, level)
+        questions = [q.strip() for q in all_questions_str.split('\n') if q.strip()]
+        questions = questions[:NUM_QUESTIONS]
+
+        correct_answers = 0
+        per_question_feedback = []  # collect feedback for summary
+        
+        for i, question_text in enumerate(questions):
+            current_question = ". ".join(question_text.split('. ')[1:])
+            
+            print(f"\n----------\n[Question {i+1}/{len(questions)}] {current_question}")
+            user_answer = input("Your answer: ")
+            try:
+                evaluation_json_str = self.evaluate_answer(topic, level, current_question, user_answer)
+                evaluation_data = json.loads(evaluation_json_str)
+
+                evaluation = str(evaluation_data.get("evaluation", "incorrect")).lower()
+                reasoning = evaluation_data.get("reasoning", "No explanation provided.")
+                hint = evaluation_data.get("hint", "")
+
+                is_correct = evaluation == "correct"
+                if is_correct:
+                    correct_answers += 1
+                    print(f"[Feedback] {reasoning}")
+                    print("✅ Correct!")
+                else:
+                    print(f"[Feedback] {reasoning}")
+                    print("❌ Incorrect.")
+                    if hint:
+                        print(f"💡 Hint: {hint}")
+
+                per_question_feedback.append({
+                    "question": current_question,
+                    "correct": is_correct,
+                    "reason": reasoning,
+                    "hint": hint,
+                })
+
+            except (json.JSONDecodeError, AttributeError) as e:
+                print(f"[System Error] Could not parse the evaluation. Let's skip this one. Error: {e}")
+                continue
+
+        score_percentage = (correct_answers / len(questions)) * 100
+        # Print detailed feedback summary
+        print("\n----------")
+        print("ASSESSMENT FEEDBACK SUMMARY")
+        for i, fb in enumerate(per_question_feedback, 1):
+            tag = "✅" if fb["correct"] else "❌"
+            print(f"{tag} Q{i}: {fb['question']}")
+            if fb.get("reason"):
+                print(f"   Reason: {fb['reason']}")
+            if (not fb["correct"]) and fb.get("hint"):
+                print(f"   Hint: {fb['hint']}")
+
+        print(f"\n[Assessment Complete] You scored {score_percentage:.1f}% ({correct_answers}/{len(questions)} questions correct).")
+
+        # Level determination based on claimed level thresholds
+        if level == "advanced":
+            if score_percentage >= 70:
+                print("🎯 Assigned Level: advanced")
+                return "advanced"
+            elif score_percentage >= 65:
+                print("🎯 Assigned Level: intermediate")
+                return "intermediate"
+            else:
+                print("🎯 Assigned Level: novice")
+                return "novice"
+        elif level == "intermediate":
+            if score_percentage >= 65:
+                print("🎯 Assigned Level: intermediate")
+                return "intermediate"
+            else:
+                print("🎯 Assigned Level: novice")
+                return "novice"
+        else:
+            print("🎯 Assigned Level: novice")
+            return "novice"

agents/teacher.py

@@ -0,0 +1,238 @@
+# agents/teacher.py
+import os
+import json
+import time
+from dotenv import load_dotenv
+import openai
+from .base_agent import BaseAgent
+
+load_dotenv()
+
+
+class TeacherAgent(BaseAgent):
+    def __init__(self, level):
+        super().__init__(f"{level.capitalize()}TeacherAgent")
+        api_key = os.getenv("OPENAI_API_KEY")
+        self.client = openai.OpenAI(api_key=api_key)
+        self.level = level.lower()
+
+    def teach_module(self, module):
+        """
+        Returns a rich, k-shot based explanation string for the given module.
+        Will attempt a small re-prompt if the output is too short.
+        """
+        system_prompt = (
+            "You are an engaging and adaptive AI Tutor. Produce a thorough, structured explanation "
+            "of the requested module tuned to the user's learning level. Use the structure below."
+            "\n\nTeaching style differences by level:\n"
+            "- Novice: Simple language, relatable analogies, many concrete examples.\n"
+            "- Intermediate: Explain 'how' and 'why', connect to related concepts, include practical examples.\n"
+            "- Advanced: Discuss nuances, edge-cases, performance, comparative methods and deeper insights.\n\n"
+            "Explanation structure (MANDATORY):\n"
+            "1) Core Concept — clear, precise description (several sentences)\n"
+            "2) Worked Example or Analogy — at least one detailed example that illustrates application\n"
+            "4) Key Takeaway — one concise sentence\n\n"
+            "### Few-shot examples (follow style):\n\n"
+            "Novice Example:\n"
+            "Module: Variables\n"
+            "Core Concept: Variables are containers that store values like numbers or text. Example: x = 5.\n"
+            "Analogy/Example: Think of a labeled jar.\n"
+            "Intermediate Example:\n"
+            "Module: For loops\n"
+            "Core Concept: For loops iterate over a collection. Example: for item in collection: process(item)\n"
+            "Application: Useful for batch-processing and iteration in algorithms.\n\n"
+            "Advanced Example:\n"
+            "Module: Tail recursion\n"
+            "Core Concept: Tail recursion preserves state for compiler optimizations; consider stack usage.\n\n"
+            "Produce detailed output (minimum ~130 words). Do NOT output JSON — just plain text explanation."
+        )
+
+        user_prompt = (
+            f"Module: {module.name}\n"
+            f"Learning objective: {getattr(module, 'learning_objective', '')}\n\n"
+            "Please produce the explanation now."
+        )
+
+        resp = self.client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt}
+            ],
+            # you can tune temperature if needed
+        )
+        explanation = resp.choices[0].message.content.strip()
+
+        # If too short, ask for expansion once
+        if len(explanation.split()) < 120:
+            followup = (
+                "The previous explanation was too short. Please expand the explanation, add another worked example "
+                "and a short code or pseudo-code snippet where appropriate. Keep same style & level."
+            )
+            resp2 = self.client.chat.completions.create(
+                model="gpt-4o-mini",
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt},
+                    {"role": "user", "content": followup}
+                ],
+            )
+            extra = resp2.choices[0].message.content.strip()
+            # concatenate but keep readable
+            explanation = explanation + "\n\n" + extra
+
+        # return explanation string (do not print in agent; app will show it)
+        return explanation
+
+    def evaluate_example(self, module, student_example):
+        """
+        Evaluate the student's example for the given module.
+        Returns a dict: { "is_correct": bool, "feedback": str, "confidence": float (0-1) }
+        The model MUST output JSON only; we robustly parse it and fallback if needed.
+        """
+        system_prompt = (
+            "You are an expert educational assessor. Evaluate the student's example strictly with respect "
+            "to the module's learning objective. Respond with JSON ONLY (no extra text). The JSON object MUST contain:\n"
+            " - is_correct: true/false\n"
+            " - feedback: short one-sentence constructive feedback\n"
+            " - confidence: numeric between 0 and 1\n\n"
+            f"Evaluation sensitivity is based on learner level: {self.level}."
+        )
+
+        user_prompt = (
+            f"Module: {module.name}\n"
+            f"Learning objective: {getattr(module, 'learning_objective', '')}\n\n"
+            f"Student example: {student_example}\n\n"
+            "Evaluate and return JSON only."
+        )
+
+        resp = self.client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt}
+            ],
+            # lower temperature can reduce hallucinations
+        )
+        raw = resp.choices[0].message.content.strip()
+
+        # Try to parse JSON; be forgiving (extract first {...})
+        try:
+            parsed = json.loads(raw)
+        except Exception:
+            import re
+            m = re.search(r'(\{.*\})', raw, re.DOTALL)
+            if m:
+                try:
+                    parsed = json.loads(m.group(1))
+                except Exception:
+                    parsed = None
+            else:
+                parsed = None
+
+        if not parsed:
+            # fallback: simple heuristics (very conservative)
+            is_correct = len(student_example.strip()) > 20
+            feedback = "Could not parse evaluator output; using conservative heuristic. Provide a more concrete example." \
+                if not is_correct else "Example seems plausible but automatic evaluation failed to parse."
+            confidence = 0.45 if not is_correct else 0.6
+            return {"is_correct": bool(is_correct), "feedback": feedback, "confidence": confidence, "raw": raw}
+
+        # normalize fields
+        is_correct = bool(parsed.get("is_correct", parsed.get("correct", False)))
+        feedback = str(parsed.get("feedback", parsed.get("explanation", "")))
+        confidence = float(parsed.get("confidence", parsed.get("score", 0))) if parsed.get("confidence") is not None else 0.9
+
+        return {"is_correct": is_correct, "feedback": feedback, "confidence": confidence, "raw": raw}
+
+    def check_example(self, module):
+        """
+        Interactive method to check if student understands the module by asking for an example.
+        Returns True if the student provides a satisfactory example, False otherwise.
+        """
+        print(f"\n🎯 Let's test your understanding of '{module.name}'!")
+        print("Please provide a specific example or application that demonstrates this concept.")
+        
+        learning_objective = getattr(module, 'learning_objective', '')
+        if learning_objective:
+            print(f"Learning Objective: {learning_objective}")
+        
+        print("\nYour example should be:")
+        print("• Specific and concrete (not just a definition)")
+        print("• Relevant to the module content")
+        print("• Show your understanding of how to apply the concept")
+        print("• At least 2-3 sentences with clear reasoning")
+        
+        while True:  # Allow multiple attempts
+            student_example = input("\nYour example: ").strip()
+            
+            if not student_example:
+                print("❌ Please provide an example to demonstrate your understanding.")
+                continue
+            
+            # Check for minimum length and specificity
+            if len(student_example.split()) < 10:
+                print("❌ Your example is too brief. Please provide a more detailed example with specific details.")
+                continue
+            
+            # Evaluate the example
+            evaluation = self.evaluate_example(module, student_example)
+            
+            if evaluation['is_correct']:
+                print("✅ Correct! Your example demonstrates good understanding.")
+                return True
+            else:
+                print("❌ Incorrect. Your example doesn't demonstrate sufficient understanding.")
+                
+                # Provide a simple hint
+                hint = self.get_simple_hint(module)
+                if hint:
+                    print(f"💡 Hint: {hint}")
+                
+                retry = input("\nWould you like to try again with a different example? (y/n): ").lower().strip()
+                if retry == 'y':
+                    continue
+                else:
+                    print("📚 Let's review the concept again and then try the example.")
+                    return False
+
+    def get_simple_hint(self, module):
+        """Generate a simple hint to guide the student toward a better example."""
+        system_prompt = (
+            "You are an expert tutor providing a simple hint. Give a brief, helpful suggestion (1-2 sentences) "
+            "to guide the student toward providing a better example. Don't give away the answer, just nudge them in the right direction."
+        )
+        
+        user_prompt = (
+            f"Module: {module.name}\n"
+            f"Learning Objective: {getattr(module, 'learning_objective', '')}\n\n"
+            "Provide a simple hint to help the student think of a better example."
+        )
+        
+        try:
+            response = self.client.chat.completions.create(
+                model="gpt-4o-mini",
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt}
+                ]
+            )
+            return response.choices[0].message.content.strip()
+        except Exception:
+            return "Think about how this concept applies in real-world situations or practical scenarios."
+
+
+# convenience subclasses (optional)
+class NoviceTeacherAgent(TeacherAgent):
+    def __init__(self):
+        super().__init__("novice")
+
+
+class IntermediateTeacherAgent(TeacherAgent):
+    def __init__(self):
+        super().__init__("intermediate")
+
+
+class AdvancedTeacherAgent(TeacherAgent):
+    def __init__(self):
+        super().__init__("advanced")

app.py

@@ -0,0 +1,951 @@
+#!/usr/bin/env python3
+"""
+AI Teacher Bot - Single Panel UI (fixed example-evaluation & progression)
+"""
+
+import gradio as gr
+import io
+from contextlib import redirect_stdout
+
+from main import LEVELS, check_api_key, generate_curriculum
+from user_state import UserState
+from agents.level_assess import LevelAssessmentAgent
+from agents.teacher import TeacherAgent
+from agents.bloom_assess import BloomsAssessmentAgent
+import json
+
+# Global session
+current_session = {
+    "user": None,
+    "curriculum": None,
+    "chapter_idx": 0,
+    "module_idx": 0,
+    "mode": None,  # modes: None/idle, "assessment", "teaching", "awaiting_example", "module_passed", "bloom", "done"
+    "questions": [],
+    "answers": [],
+    "q_idx": 0,
+    "bloom_level": None,
+    # assessment flow controls
+    "correct_count": 0,
+    "assessment_feedback": [],  # list of dicts per question with correctness and feedback
+    "last_feedback": None,  # stores last question, answer, evaluation, reasoning for challenging
+    "challenge_chat_history": [],  # list of [user_msg, assistant_msg] pairs for challenge discussion
+    "challenge_exchanges": 0,  # count of challenge exchanges (max 3)
+    "challenge_mode": False,  # whether challenge chat is active
+    "last_output": ""
+}
+
+BLOOM_ORDER = ["remember", "understand", "apply", "analyze", "evaluate", "create"]
+
+
+def update_main_output(text):
+    current_session["last_output"] = text
+    return text
+
+# ------------------------------
+# Chatbot helpers (Gradio 6 safe)
+# ------------------------------
+def empty_chat():
+    """
+    Returns empty chat in messages format (dictionaries with 'role' and 'content' keys).
+    """
+    return [{"role": "assistant", "content": " "}]
+
+
+def safe_chat(chat):
+    """
+    Ensures chat history is always valid. Uses messages format (list of dicts with 'role' and 'content').
+    """
+    if not isinstance(chat, list):
+        return empty_chat()
+    if len(chat) == 0:
+        return empty_chat()
+    # Ensure all items are dicts with role and content
+    result = []
+    for item in chat:
+        if isinstance(item, dict) and "role" in item and "content" in item:
+            result.append(item)
+        elif isinstance(item, tuple) and len(item) == 2:
+            # Convert tuple (user_msg, assistant_msg) to dict format
+            result.append({"role": "user", "content": item[0]})
+            result.append({"role": "assistant", "content": item[1]})
+    return result if result else empty_chat()
+
+
+def get_output_update():
+    return gr.update(value=current_session.get("last_output", ""))
+
+# ------------------------------
+# Session & Flow helpers
+# ------------------------------
+def reset_session_state():
+    current_session.update({
+        "user": None,
+        "curriculum": None,
+        "chapter_idx": 0,
+        "module_idx": 0,
+        "mode": None,
+        "questions": [],
+        "answers": [],
+        "q_idx": 0,
+        "bloom_level": None,
+        "correct_count": 0,
+        "assessment_feedback": [],
+        "last_feedback": None,
+        "challenge_chat_history": [],
+        "challenge_exchanges": 0,
+        "challenge_mode": False,
+        "last_output": ""
+    })
+
+def start_learning_session(topic, claimed_level):
+    if not topic or not topic.strip():
+        return "❌ Please enter a topic"
+    if not check_api_key():
+        return "❌ OpenAI API key not configured! Please set OPENAI_API_KEY in your .env file."
+
+    try:
+        reset_session_state()
+        user = UserState(topic=topic.strip(), claimed_level=claimed_level)
+        current_session["user"] = user
+
+        # Generate curriculum (level may be updated later after assessment)
+        curriculum = generate_curriculum(user.topic, claimed_level)
+        if curriculum is None:
+            return "❌ Failed to generate curriculum. Please try again or check your API key."
+        current_session["curriculum"] = curriculum
+    except Exception as e:
+        return f"❌ Error starting session: {str(e)}. Please try again."
+
+    if claimed_level == "novice":
+        user.set_actual_level("novice")
+        current_session["mode"] = None  # ready to start teaching
+        return update_main_output(show_curriculum(curriculum) + "\n\nType 'next' to start Module 1.")
+    else:
+        # start level assessment
+        assessor = LevelAssessmentAgent()
+        q_text = assessor.generate_questions(user.topic, claimed_level)
+        questions = [q.strip() for q in q_text.split("\n") if q.strip() and q[0].isdigit()]
+        if not questions:
+            # fallback: skip assessment
+            user.set_actual_level(claimed_level)
+            current_session["mode"] = None
+            return update_main_output(show_curriculum(curriculum) + "\n\nType 'next' to start Module 1.")
+        current_session.update({
+            "mode": "assessment",
+            "questions": questions,
+            "q_idx": 0,
+            "answers": [],
+            "correct_count": 0,
+            "assessment_feedback": [],
+            "last_feedback": None,  # Will be set after first answer submission
+            "challenge_chat_history": [],
+            "challenge_exchanges": 0,
+            "challenge_mode": False
+        })
+        # Button should be hidden initially (no feedback yet), will show after first answer
+        return update_main_output(f"📝 LEVEL ASSESSMENT\n\nQuestion 1 of {len(questions)}:\n{questions[0]}\n\nPlease submit your answer.")
+
+# ------------------------------
+# Level assessment handlers
+# ------------------------------
+def _strip_number_prefix(q_line: str) -> str:
+    # Converts "1. Question" -> "Question" safely
+    q = q_line.strip()
+    if ". " in q:
+        parts = q.split(". ", 1)
+        if parts[0].isdigit():
+            return parts[1]
+    return q
+
+
+def handle_assessment(answer):
+    qs = current_session["questions"]
+    idx = current_session["q_idx"]
+
+    if not qs:
+        return "⚠️ No assessment in progress."
+
+    question_full = qs[idx]
+    question = _strip_number_prefix(question_full)
+
+    # guard on empty/very short answers
+    user_answer = (answer or "").strip()
+    if len(user_answer.split()) < 5:
+        # Don't set last_feedback for invalid answers, so button won't show
+        return "❌ Your answer is too brief. Please provide a more detailed and specific response (at least 5 words or 1-2 sentences)."
+
+    assessor = LevelAssessmentAgent()
+    try:
+        raw = assessor.evaluate_answer(
+            current_session["user"].topic,
+            current_session["user"].claimed_level,
+            question,
+            user_answer,
+        )
+        import json as _json
+        parsed = _json.loads(raw)
+        evaluation = str(parsed.get("evaluation", "incorrect")).lower()
+        reasoning = parsed.get("reasoning", "")
+        hint = parsed.get("hint", "")  # Extract hint for completeness
+    except Exception as e:
+        # Better error handling
+        evaluation = "correct" if len(user_answer.split()) >= 20 else "incorrect"
+        reasoning = f"Heuristic grading fallback used. (Error: {str(e)})"
+        hint = ""
+
+    # Record attempt
+    current_session["answers"].append(user_answer)
+    is_correct = evaluation == "correct"
+    if is_correct:
+        current_session["correct_count"] += 1
+
+    # Save per-question feedback
+    current_session["assessment_feedback"].append({
+        "question": question,
+        "correct": is_correct,
+        "reason": reasoning,
+        "hint": hint,
+    })
+    
+    # Store last feedback for challenging
+    current_session["last_feedback"] = {
+        "question": question,
+        "answer": user_answer,
+        "evaluation": evaluation,
+        "reasoning": reasoning,
+        "is_correct": is_correct,
+        "hint": hint
+    }
+
+    # Advance to next question or finish
+    if idx + 1 < len(qs):
+        current_session["q_idx"] += 1
+        status = "✅ Correct!" if is_correct else "❌ Incorrect."
+        extra = f"\nReason: {reasoning}" if reasoning else ""
+        hint_text = f"\n💡 Hint: {hint}" if hint and not is_correct else ""
+        return (
+            f"{status}{extra}{hint_text}\n\n"
+            f"Question {current_session['q_idx']+1} of {len(qs)}:\n{qs[current_session['q_idx']]}"
+        )
+    else:
+        # Finish: compute score and assign level based on claimed level thresholds
+        total = len(qs)
+        score_pct = (current_session["correct_count"] / total) * 100
+        claimed = current_session["user"].claimed_level
+
+        if claimed == "advanced":
+            if score_pct >= 70:
+                assigned = "advanced"
+            elif score_pct >= 65:
+                assigned = "intermediate"
+            else:
+                assigned = "novice"
+        elif claimed == "intermediate":
+            assigned = "intermediate" if score_pct >= 65 else "novice"
+        else:
+            assigned = "novice"
+
+        # Build full feedback summary
+        lines = [
+            "🧪 Assessment Feedback:",
+        ]
+        for i, fb in enumerate(current_session["assessment_feedback"], 1):
+            tag = "✅" if fb["correct"] else "❌"
+            line = f"{tag} Q{i}: {fb['question']}"
+            if fb.get("reason"):
+                line += f"\n   Reason: {fb['reason']}"
+            lines.append(line)
+        lines.append("")
+        lines.append(f"Score: {score_pct:.1f}%  |  Assigned Level: {assigned}")
+
+        current_session["user"].set_actual_level(assigned)
+        # Prepare curriculum but show it on next screen
+        curriculum = generate_curriculum(current_session["user"].topic, assigned)
+        if curriculum:
+            current_session["curriculum"] = curriculum
+
+        feedback_text = "\n".join(lines)
+        current_session["mode"] = "assessment_summary"
+        current_session["last_feedback"] = None  # Clear last feedback when assessment completes
+        return feedback_text + "\n\n➡️ Press 'Next' to view your personalized curriculum."
+
+# ------------------------------
+# Teaching helpers
+# ------------------------------
+def show_curriculum(curriculum):
+    txt = f"📖 CURRICULUM FOR {current_session['user'].topic.upper()}\n" + "="*40 + "\n"
+    for i, ch in enumerate(curriculum.chapters, 1):
+        txt += f"\nChapter {i}: {ch.name}\n"
+        for j, mod in enumerate(ch.modules, 1):
+            txt += f"  {i}.{j} {mod.name}\n"
+            if getattr(mod, "learning_objective", None):
+                txt += f"     → {mod.learning_objective}\n"
+    return txt
+
+def next_step(_):
+    mode = current_session["mode"]
+    # If module just passed, Next moves to next module
+    if mode == "module_passed":
+        # advance module index now
+        current_session["module_idx"] += 1
+        current_session["mode"] = None
+        return update_main_output(start_teaching_module())
+    # If idle/none → start teaching module
+    if mode is None:
+        return update_main_output(start_teaching_module())
+    if mode == "teaching":
+        return update_main_output(get_explanation())
+    if mode == "awaiting_example":
+        return update_main_output("✋ Please submit your example using 'Submit Answer' before moving on.")
+    if mode == "bloom":
+        return update_main_output("🌸 Bloom assessment in progress — answer the Bloom question or submit to retry.")
+    if mode == "assessment_summary":
+        # show curriculum now and transition to normal teaching flow
+        current_session["mode"] = None
+        return update_main_output(show_curriculum(current_session["curriculum"]) + "\n\nType 'next' to start Module 1.")
+    return update_main_output("⚠️ Invalid state.")
+
+def start_teaching_module():
+    if not current_session.get("curriculum"):
+        return "⚠️ No curriculum loaded. Please start a session first."
+    
+    try:
+        cur = current_session["curriculum"]
+        ch_i = current_session["chapter_idx"]
+        m_i = current_session["module_idx"]
+
+        if ch_i >= len(cur.chapters):
+            current_session["mode"] = "done"
+            return "🎉 You have completed the entire curriculum!"
+        
+        chapter = cur.chapters[ch_i]
+        # if all modules finished -> start Bloom for the chapter
+        if m_i >= len(chapter.modules):
+            return start_bloom_assessment()
+
+        module = chapter.modules[m_i]
+        current_session["mode"] = "teaching"
+        return f"📚 Chapter {ch_i+1}: {chapter.name}\nModule {ch_i+1}.{m_i+1}: {module.name}\n\nObjective: {getattr(module,'learning_objective','')}\n\nClick 'Next' to get the explanation."
+    except Exception as e:
+        return f"❌ Error starting teaching module: {str(e)}"
+
+def get_explanation():
+    if not current_session.get("curriculum") or not current_session.get("user"):
+        return "⚠️ Session not properly initialized. Please start a new session."
+    
+    try:
+        cur = current_session["curriculum"]
+        ch_i = current_session["chapter_idx"]
+        m_i = current_session["module_idx"]
+        chapter = cur.chapters[ch_i]
+        # Guard
+        if m_i >= len(chapter.modules):
+            return start_bloom_assessment()
+
+        module = chapter.modules[m_i]
+        teacher = TeacherAgent(current_session["user"].actual_level or current_session["user"].claimed_level)
+        explanation = teacher.teach_module(module)  # returns string
+        current_session["mode"] = "awaiting_example"
+        return f"📖 Explanation for {module.name}\n\n{explanation}\n\n✍️ Now submit your example in the box and click 'Submit Answer'."
+    except Exception as e:
+        return f"❌ Error getting explanation: {str(e)}"
+
+# ------------------------------
+# Submit handler (single entry point wired to Submit button)
+# ------------------------------
+def submit_answer(answer):
+    mode = current_session.get("mode")
+    if mode == "assessment":
+        response = handle_assessment(answer)
+    elif mode == "awaiting_example":
+        response = handle_example_submission(answer)
+    elif mode == "bloom":
+        response = handle_bloom(answer)
+    else:
+        response = "⚠️ Nothing to submit right now. Click 'Next' to proceed."
+    current_session["last_output"] = response
+    # Return output + clear input
+    return response, ""
+
+def start_challenge_discussion():
+    """
+    Opens the challenge discussion chat interface as a modal pop-up.
+    Shows the original feedback and prompts user to start discussion.
+    """
+    mode = current_session.get("mode")
+    if mode != "assessment":
+        return gr.update(visible=False), [], "⚠️ Challenge is only available during assessment.", get_output_update()
+    
+    last_fb = current_session.get("last_feedback")
+    if not last_fb:
+        return gr.update(visible=False), [], "⚠️ No feedback available to challenge. Please submit an answer first.", get_output_update()
+    
+    # Initialize challenge discussion
+    current_session["challenge_mode"] = True
+    current_session["challenge_exchanges"] = 0
+    current_session["challenge_chat_history"] = []
+    
+    # Show initial context
+    initial_greeting = (
+        f"**Grader's Original Feedback:**\n"
+        f"Evaluation: {'✅ Correct' if last_fb['is_correct'] else '❌ Incorrect'}\n"
+        f"Reasoning: {last_fb['reasoning']}\n\n"
+        f"**Question:** {last_fb['question']}\n"
+        f"**Your Answer:** {last_fb['answer']}\n\n"
+        f"💬 You can now present your arguments. You have up to 3 exchanges with the grader."
+    )
+    
+    # Use messages format: list of dicts with 'role' and 'content'
+    chat_history = [{"role": "assistant", "content": initial_greeting}]
+    status_msg = "💬 Challenge discussion opened. Present your first argument below (3 exchanges remaining)."
+    
+    return (
+    gr.update(visible=True),
+    chat_history,
+    status_msg,
+    get_output_update()
+)
+
+def handle_challenge_message(message, chat_history):
+    """
+    Handles a message in the challenge discussion.
+    Limits to 3 total exchanges (student messages).
+    Returns: chat_history, status_msg, msg_enabled, btn_enabled, output_update
+    """
+    if not current_session.get("challenge_mode"):
+        return chat_history, "⚠️ Challenge discussion is not active.", False, False, get_output_update()
+    
+    if not message or not message.strip():
+        return chat_history, "", True, True, gr.update()
+    
+    if current_session["challenge_exchanges"] >= 3:
+        return chat_history, "⚠️ Maximum exchanges (3) reached. Discussion closed. Click 'Close Discussion' to continue.", False, False, get_output_update()
+    
+    last_fb = current_session.get("last_feedback")
+    if not last_fb:
+        return chat_history, "⚠️ No feedback available.", False, False, get_output_update()
+    
+    assessor = LevelAssessmentAgent()
+    try:
+        grader_response = assessor.challenge_discussion(
+            current_session["user"].topic,
+            current_session["user"].claimed_level,
+            last_fb["question"],
+            last_fb["answer"],
+            last_fb["evaluation"],
+            last_fb["reasoning"],
+            current_session["challenge_chat_history"],
+            message
+        )
+        
+        current_session["challenge_chat_history"].append([message, grader_response])
+        current_session["challenge_exchanges"] += 1
+        
+        # Ensure chat_history is in messages format (list of dicts)
+        chat_history = safe_chat(chat_history)
+        
+        # Add the new messages in messages format
+        chat_history.append({"role": "user", "content": message})
+        chat_history.append({"role": "assistant", "content": grader_response})
+
+        
+        remaining = 3 - current_session["challenge_exchanges"]
+        if remaining > 0:
+            status_msg = f"💬 {remaining} exchange(s) remaining. You can continue the discussion."
+            output_update = gr.update()
+            msg_enabled = True
+            btn_enabled = True
+        else:
+            # Finalize evaluation after 3 exchanges
+            status_msg, output_update = finalize_challenge_discussion(grader_response)
+            msg_enabled = False
+            btn_enabled = False
+        
+        return chat_history, status_msg, msg_enabled, btn_enabled, output_update
+    except Exception as e:
+        return chat_history, f"❌ Error: {str(e)}", True, True, gr.update()
+
+def finalize_challenge_discussion(final_response):
+    """
+    Finalizes the challenge discussion and updates evaluation if needed.
+    Extracts final evaluation from the last grader response.
+    Returns: (status_msg, main_output_update)
+    """
+    last_fb = current_session.get("last_feedback")
+    if not last_fb:
+        return "⚠️ Could not finalize challenge.", get_output_update()
+    
+    # Try to extract evaluation from the final response
+    # Use the challenge_feedback method to get a structured final evaluation
+    assessor = LevelAssessmentAgent()
+    try:
+        # Get the full conversation context
+        conversation_text = "\n".join([
+            f"Student: {msg[0]}\nGrader: {msg[1]}"
+            for msg in current_session["challenge_chat_history"]
+        ])
+        
+        # Final re-evaluation request
+        final_prompt = (
+            f"Based on our discussion:\n{conversation_text}\n\n"
+            "Please provide your FINAL evaluation as JSON with: "
+            '{"evaluation": "correct" or "incorrect", "reasoning": "explanation", "original_was_fair": true/false}'
+        )
+        
+        raw = assessor.challenge_feedback(
+            current_session["user"].topic,
+            current_session["user"].claimed_level,
+            last_fb["question"],
+            last_fb["answer"],
+            last_fb["evaluation"],
+            last_fb["reasoning"]
+        )
+        
+        import json as _json
+        parsed = _json.loads(raw)
+        new_evaluation = str(parsed.get("evaluation", "incorrect")).lower()
+        new_reasoning = parsed.get("reasoning", "")
+        original_was_fair = parsed.get("original_was_fair", True)
+        
+        new_is_correct = new_evaluation == "correct"
+        old_is_correct = last_fb["is_correct"]
+        
+        # Build the main output update
+        qs = current_session["questions"]
+        idx = current_session["q_idx"]
+        current_question_text = ""
+        if idx < len(qs):
+            current_question_text = f"\n\n📝 Current Question {idx+1} of {len(qs)}:\n{qs[idx]}"
+        
+        # Update if evaluation changed
+        if new_is_correct != old_is_correct:
+            if new_is_correct and not old_is_correct:
+                current_session["correct_count"] += 1
+            elif not new_is_correct and old_is_correct:
+                current_session["correct_count"] = max(0, current_session["correct_count"] - 1)
+            
+            if current_session["assessment_feedback"]:
+                current_session["assessment_feedback"][-1]["correct"] = new_is_correct
+                current_session["assessment_feedback"][-1]["reason"] = new_reasoning
+            
+            current_session["last_feedback"]["evaluation"] = new_evaluation
+            current_session["last_feedback"]["reasoning"] = new_reasoning
+            current_session["last_feedback"]["is_correct"] = new_is_correct
+            
+            # Build updated main output
+            main_output = (
+                f"🔄 **EVALUATION UPDATED AFTER CHALLENGE**\n\n"
+                f"**Question:** {last_fb['question']}\n"
+                f"**Your Answer:** {last_fb['answer']}\n\n"
+                f"**Original Evaluation:** {'✅ Correct' if old_is_correct else '❌ Incorrect'}\n"
+                f"**Updated Evaluation:** {'✅ Correct' if new_is_correct else '❌ Incorrect'}\n\n"
+                f"**Updated Reasoning:** {new_reasoning}\n"
+                f"{current_question_text}"
+            )
+            
+            status_msg = "🔄 **FINAL EVALUATION UPDATED**\n\n" + \
+                        f"**New Evaluation:** {'✅ Correct' if new_is_correct else '❌ Incorrect'}\n" + \
+                        f"**Final Reasoning:** {new_reasoning}\n\n" + \
+                        "✅ Challenge discussion completed. Evaluation has been updated on the main screen."
+        else:
+            # Build main output showing final evaluation
+            main_output = (
+                f"📋 **FINAL EVALUATION AFTER CHALLENGE**\n\n"
+                f"**Question:** {last_fb['question']}\n"
+                f"**Your Answer:** {last_fb['answer']}\n\n"
+                f"**Evaluation:** {'✅ Correct' if new_is_correct else '❌ Incorrect'} (unchanged)\n\n"
+                f"**Final Reasoning:** {new_reasoning}\n"
+                f"{current_question_text}"
+            )
+            
+            status_msg = "📋 **FINAL EVALUATION**\n\n" + \
+                        f"**Evaluation:** {'✅ Correct' if new_is_correct else '❌ Incorrect'} (unchanged)\n" + \
+                        f"**Final Reasoning:** {new_reasoning}\n\n" + \
+                        "✅ Challenge discussion completed. You may continue with the assessment."
+        
+        # Close challenge mode
+        current_session["challenge_mode"] = False
+        current_session["last_output"] = main_output
+        
+        return status_msg, gr.update(value=main_output)
+    except Exception as e:
+        current_session["challenge_mode"] = False
+        error_msg = f"⚠️ Error finalizing challenge: {str(e)}"
+        return error_msg, get_output_update()
+
+def handle_example_submission(example_text):
+    """
+    Uses TeacherAgent.evaluate_example(module, example) to decide correctness.
+    If correct -> set mode to 'module_passed' and require user to press Next to move on.
+    If incorrect -> remain in 'awaiting_example' and show feedback.
+    """
+    if not current_session.get("curriculum"):
+        return "⚠️ No curriculum loaded. Please start a session first."
+    
+    cur = current_session["curriculum"]
+    ch_i = current_session["chapter_idx"]
+    m_i = current_session["module_idx"]
+    
+    if ch_i >= len(cur.chapters):
+        return "⚠️ No active chapter available."
+    
+    chapter = cur.chapters[ch_i]
+    if m_i >= len(chapter.modules):
+        # Shouldn't happen, but guard
+        return "⚠️ No active module to evaluate."
+
+    module = chapter.modules[m_i]
+    teacher = TeacherAgent(current_session["user"].actual_level or current_session["user"].claimed_level)
+
+    # quick client-side guardrails for empty/brief examples
+    if not example_text or not str(example_text).strip():
+        return "❌ Please provide an example to demonstrate your understanding."
+    if len(str(example_text).strip().split()) < 10:
+        return "❌ Your example is too brief. Provide 2-3 sentences with specific details."
+
+    try:
+        eval_result = teacher.evaluate_example(module, example_text)
+        is_correct = bool(eval_result.get("is_correct"))
+        feedback = eval_result.get("feedback", "No feedback provided.")
+        confidence = eval_result.get("confidence", None)
+    except Exception as e:
+        return f"❌ Error evaluating example: {str(e)}. Please try again."
+
+    if is_correct:
+        # mark module as passed (do not auto-increment module_idx — require Next)
+        current_session["mode"] = "module_passed"
+        return f"✅ Example accepted. Feedback: {feedback}\n\n➡️ Click 'Next' to continue to the next module."
+    else:
+        # remain in awaiting_example — must retry
+        current_session["mode"] = "awaiting_example"
+        return f"❌ Example not sufficient. Feedback: {feedback}\n\nPlease try another example for the same module."
+
+# ------------------------------
+# Bloom assessment (per chapter)
+# ------------------------------
+def start_bloom_assessment():
+    if not current_session.get("curriculum"):
+        return "⚠️ No curriculum loaded. Please start a session first."
+    
+    try:
+        current_session["mode"] = "bloom"
+        current_session["bloom_level"] = BLOOM_ORDER[0]
+        chapter = current_session["curriculum"].chapters[current_session["chapter_idx"]]
+        return ask_bloom_question(current_session["bloom_level"], chapter)
+    except Exception as e:
+        return f"❌ Error starting Bloom assessment: {str(e)}"
+
+def ask_bloom_question(level, chapter):
+    try:
+        agent = BloomsAssessmentAgent()
+        # agent.generate_bloom_question expects (chapter, bloom_level)
+        q = agent.generate_bloom_question(chapter, level)
+        current_session["questions"] = [q]
+        return f"🌸 Bloom's Assessment ({level.title()}) for Chapter: {chapter.name}\n\n{q}\n\n✍️ Answer below and click Submit."
+    except Exception as e:
+        return f"❌ Error generating Bloom question: {str(e)}"
+
+def handle_bloom(answer):
+    if not current_session.get("curriculum"):
+        return "⚠️ No curriculum loaded. Please start a session first."
+    
+    if not answer or not str(answer).strip():
+        return "❌ Please provide an answer for the Bloom assessment question."
+    
+    try:
+        level = current_session["bloom_level"]
+        if not current_session["questions"]:
+            return "⚠️ No question available. Please start a new session."
+        question = current_session["questions"][0]
+        chapter = current_session["curriculum"].chapters[current_session["chapter_idx"]]
+        agent = BloomsAssessmentAgent()
+
+        # agent.evaluate_bloom_answer returns a JSON string per your agent implementation
+        raw_eval = agent.evaluate_bloom_answer(question, answer, level, chapter)
+
+        # parse evaluation JSON
+        try:
+            eval_obj = json.loads(raw_eval)
+            score = float(eval_obj.get("score", 0))
+            feedback = str(eval_obj.get("feedback", "No feedback"))
+        except (json.JSONDecodeError, ValueError) as e:
+            # fallback: if text contains 'correct' treat as pass
+            feedback = f"Could not parse evaluation response. Raw: {raw_eval[:100]}..."
+            score = 10 if "correct" in raw_eval.lower() else 0
+    except KeyError as e:
+        return f"❌ Session error: Missing required data ({str(e)}). Please restart the session."
+    except Exception as e:
+        return f"❌ Error evaluating Bloom answer: {str(e)}. Please try again."
+
+    # use threshold (e.g., >=6/10)
+    if score >= 6:
+        # advance bloom level
+        next_idx = BLOOM_ORDER.index(level) + 1
+        if next_idx < len(BLOOM_ORDER):
+            current_session["bloom_level"] = BLOOM_ORDER[next_idx]
+            # generate new question for next level
+            return f"✅ {feedback}\n\n➡️ Moving to {BLOOM_ORDER[next_idx].title()}.\n\n" + ask_bloom_question(current_session["bloom_level"], chapter)
+        else:
+            # finished Bloom for chapter -> next chapter
+            current_session["chapter_idx"] += 1
+            current_session["module_idx"] = 0
+            current_session["mode"] = None
+            return f"🎉 {feedback}\n\n✅ Bloom’s assessment completed for chapter '{chapter.name}'.\nType 'next' to continue."
+    else:
+        # ask a new question for same level
+        return f"❌ {feedback}\n\n🔁 Try another question at the same level.\n\n" + ask_bloom_question(level, chapter)
+
+# ------------------------------
+# Gradio UI wiring (single unified output)
+# ------------------------------
+# Custom CSS for modal pop-up
+modal_css = """
+.modal-overlay:not([style*="display: none"]) {
+    position: fixed !important;
+    top: 0 !important;
+    left: 0 !important;
+    width: 100% !important;
+    height: 100% !important;
+    background-color: rgba(0, 0, 0, 0.5) !important;
+    z-index: 1000 !important;
+    display: flex !important;
+    align-items: center !important;
+    justify-content: center !important;
+    padding: 20px !important;
+}
+
+/* When Gradio hides the element, ensure it doesn't block interactions */
+.modal-overlay[style*="display: none"],
+.modal-overlay[style*="display:none"] {
+    display: none !important;
+    visibility: hidden !important;
+    pointer-events: none !important;
+    z-index: -1 !important;
+    opacity: 0 !important;
+}
+
+.modal-content {
+    background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%) !important;
+    border-radius: 10px !important;
+    padding: 20px !important;
+    max-width: 900px !important;
+    width: 100% !important;
+    max-height: 90vh !important;
+    overflow-y: auto !important;
+    box-shadow: 0 4px 20px rgba(0, 0, 0, 0.3) !important;
+}
+
+/* Chat window styling */
+.modal-content .gradio-chatbot {
+    background-color: #ffffff !important;
+    border-radius: 8px !important;
+    padding: 15px !important;
+    border: 2px solid #e0e0e0 !important;
+}
+
+.modal-content .gradio-chatbot .message {
+    background-color: #f8f9fa !important;
+    border-radius: 8px !important;
+    padding: 10px !important;
+    margin: 5px 0 !important;
+}
+
+.modal-content .gradio-chatbot .user-message {
+    background-color: #e3f2fd !important;
+    border-left: 4px solid #2196f3 !important;
+}
+
+.modal-content .gradio-chatbot .bot-message {
+    background-color: #f1f8e9 !important;
+    border-left: 4px solid #8bc34a !important;
+}
+
+.modal-header {
+    margin: 0 !important;
+    padding: 0 !important;
+    flex-grow: 1 !important;
+}
+
+.modal-close-btn {
+    min-width: 40px !important;
+    height: 40px !important;
+    border-radius: 50% !important;
+    font-size: 20px !important;
+    font-weight: bold !important;
+}
+
+.modal-note {
+    font-size: 12px !important;
+    color: #666 !important;
+    margin-top: 10px !important;
+}
+"""
+
+with gr.Blocks(title="AI Teacher Bot") as demo:
+    gr.Markdown("""
+# 🧠 AI Teacher Bot
+
+In this interactive learning experience, you will be prompted to select your learning level—**Beginner**, **Intermediate**, or **Advanced**. 
+
+- If you choose **Intermediate** or **Advanced**, you will be presented with an assessment designed to test your understanding of the material. The questions in these assessments are tailored to the selected level, ensuring they are **challenging and reflective of the knowledge expected at that stage**. For instance, **Intermediate-level questions** will require more in-depth explanations, not just basic one-liner answers. Similarly, **Advanced-level assessments** will be comprehensive and demand a higher level of critical thinking and subject mastery.
+""")
+
+
+    with gr.Row():
+        topic = gr.Textbox(label="📝 Topic", placeholder="e.g., Python Programming", scale=2)
+        level = gr.Dropdown(choices=LEVELS, value="novice", label="🎓 Your Level", scale=1)
+        start_btn = gr.Button("🚀 Start Session")
+
+    output = gr.Textbox(label="📚 Session Output", lines=25, interactive=False, autoscroll=True)
+    answer_box = gr.Textbox(label="✍️ Your Answer / Example", placeholder="Type your answer...", lines=5, max_lines=10)
+    with gr.Row():
+        submit_btn = gr.Button("Submit Answer")
+        next_btn = gr.Button("Next")
+        challenge_btn = gr.Button("Challenge Assessment", visible=False)
+    
+    # Challenge discussion chat interface - Modal Pop-up
+    with gr.Column(visible=False, elem_classes="modal-overlay") as challenge_modal_overlay:
+        with gr.Column(elem_classes="modal-content"):
+            with gr.Row():
+                gr.Markdown("### 💬 Challenge Discussion with Grader", elem_classes="modal-header")
+                challenge_close_btn = gr.Button("✕", elem_classes="modal-close-btn", scale=0)
+            
+            with gr.Row():
+                with gr.Column(scale=3):
+                    challenge_chat = gr.Chatbot(
+                        label="",
+                        height=400,
+                        show_label=False,
+                        container=True
+                    )
+                    challenge_status = gr.Textbox(
+                        label="Status",
+                        interactive=False,
+                        lines=2,
+                        container=True
+                    )
+                with gr.Column(scale=1):
+                    challenge_msg_box = gr.Textbox(
+                        label="Your Argument/Question",
+                        placeholder="Explain why you think your answer is correct...",
+                        lines=5,
+                        container=True
+                    )
+                    challenge_send_btn = gr.Button("Send", variant="primary")
+                    gr.Markdown("**Note:** You have up to 3 exchanges with the grader.", elem_classes="modal-note")
+
+    # Function to update challenge button visibility
+    def update_challenge_visibility():
+        mode = current_session.get("mode")
+        has_feedback = current_session.get("last_feedback") is not None
+        # Show button during assessment mode after first answer is submitted
+        should_show = (mode == "assessment" and has_feedback)
+        return gr.update(visible=should_show)
+    
+    # handlers
+    start_btn.click(
+        fn=start_learning_session, 
+        inputs=[topic, level], 
+        outputs=[output]
+    ).then(
+        fn=update_challenge_visibility,
+        inputs=None,
+        outputs=[challenge_btn]
+    )
+    
+    submit_btn.click(
+        fn=submit_answer, 
+        inputs=[answer_box], 
+        outputs=[output, answer_box]
+    ).then(
+        fn=update_challenge_visibility,
+        inputs=None,
+        outputs=[challenge_btn]
+    )
+    
+    next_btn.click(
+        fn=next_step, 
+        inputs=[answer_box], 
+        outputs=[output]
+    ).then(
+        fn=update_challenge_visibility,
+        inputs=None,
+        outputs=[challenge_btn]
+    )
+    challenge_btn.click(
+        fn=start_challenge_discussion,
+        inputs=None,
+        outputs=[challenge_modal_overlay, challenge_chat, challenge_status, output]
+    ).then(
+        fn=lambda: (gr.update(value="", interactive=True), gr.update(interactive=True)),
+        inputs=None,
+        outputs=[challenge_msg_box, challenge_send_btn]
+    )
+    
+    def send_and_clear(message, chat_history):
+        """Send message and clear input box (if needed)"""
+        history, status, msg_enabled, btn_enabled, output_update = handle_challenge_message(message, chat_history)
+        if message and message.strip():
+            msg_update = gr.update(value="", interactive=msg_enabled)
+        else:
+            msg_update = gr.update(value=message, interactive=msg_enabled)
+        btn_update = gr.update(interactive=btn_enabled)
+        return history, msg_update, status, btn_update, output_update
+    
+    challenge_send_btn.click(
+        fn=send_and_clear,
+        inputs=[challenge_msg_box, challenge_chat],
+        outputs=[challenge_chat, challenge_msg_box, challenge_status, challenge_send_btn, output]
+    )
+    
+    challenge_msg_box.submit(
+        fn=send_and_clear,
+        inputs=[challenge_msg_box, challenge_chat],
+        outputs=[challenge_chat, challenge_msg_box, challenge_status, challenge_send_btn, output]
+    )
+    
+    def close_challenge_discussion():
+        """
+        Properly closes the challenge modal and restores UI control
+        """
+        # Reset backend state
+        current_session["challenge_mode"] = False
+        current_session["challenge_chat_history"] = []
+        current_session["challenge_exchanges"] = 0
+
+        # IMPORTANT: Use visible=False to hide the overlay completely
+        # This should remove it from the DOM or set display:none which CSS will respect
+        return (
+            gr.update(visible=False),   # Hide overlay - this should remove blocking
+            empty_chat(),               # Reset chat
+            "✅ Challenge closed.",     # Status message
+            gr.update(value=current_session.get("last_output", ""))  # Keep main output
+        )
+
+    
+    challenge_close_btn.click(
+        fn=close_challenge_discussion,
+        inputs=None,
+        outputs=[
+            challenge_modal_overlay,  # visible=False
+            challenge_chat,           # reset chat
+            challenge_status,         # status text
+            output                    # main output (reevaluated decision)
+        ]
+    ).then(
+        fn=update_challenge_visibility,
+        inputs=None,
+        outputs=[challenge_btn]
+    )
+
+
+if __name__ == "__main__":
+    demo.launch(
+        share=True,
+        server_name="0.0.0.0",
+        server_port=7860,
+        theme=gr.themes.Soft(),
+        css=modal_css
+    )
+

curriculum.py

@@ -0,0 +1,41 @@
+class Curriculum:
+    def __init__(self, topic, chapters=None):
+        self.topic = topic
+        self.chapters = chapters if chapters else []  # List of Chapter objects
+
+    def add_chapter(self, chapter):
+        self.chapters.append(chapter)
+
+    def print_curriculum(self):
+        print(f"\nCurriculum for: {self.topic}\n" + "="*40)
+        for i, chapter in enumerate(self.chapters, 1):
+            print(f"\nChapter {i}: {chapter.name}")
+            print("-" * (10 + len(chapter.name)))
+            for j, module in enumerate(chapter.modules, 1):
+                print(f"  {i}.{j} {module.name}")
+                if hasattr(module, 'learning_objective') and module.learning_objective:
+                    print(f"      Learning Objective: {module.learning_objective}")
+
+    def __repr__(self):
+        return f"Curriculum(topic={self.topic}, chapters={self.chapters})"
+
+class Chapter:
+    def __init__(self, name, modules=None):
+        self.name = name
+        self.modules = modules if modules else []  # List of Module objects
+
+    def add_module(self, module):
+        self.modules.append(module)
+
+    def __repr__(self):
+        return f"Chapter(name={self.name}, modules={self.modules})"
+
+class Module:
+    def __init__(self, name, learning_objective=None, content=None):
+        self.name = name
+        self.learning_objective = learning_objective
+        self.content = content
+
+    def __repr__(self):
+        return f"Module(name={self.name}, learning_objective={self.learning_objective})"
+    

main.py

@@ -0,0 +1,162 @@
+#!/usr/bin/env python3
+"""
+AI Teacher Bot - Complete CLI Interface
+This is the main command-line interface for the AI Teacher Bot system.
+"""
+
+import os
+import sys
+import json
+from datetime import datetime
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+from user_state import UserState
+from curriculum import Curriculum, Chapter, Module
+from agents.level_assess import LevelAssessmentAgent
+from agents.curriculum_planner import CurriculumPlannerAgent
+from agents.coordinator import CoordinatorAgent
+from agents.bloom_assess import BloomsAssessmentAgent
+
+LEVELS = ['novice', 'intermediate', 'advanced']
+
+def print_banner():
+    """Print the application banner"""
+    print("=" * 60)
+    print("🧠 AI TEACHER BOT - COMPLETE LEARNING SYSTEM")
+    print("=" * 60)
+    print("Multi-Agent Adaptive Learning Platform")
+    print("Features: Level Assessment, Dynamic Curriculum, Bloom's Taxonomy")
+    print("=" * 60)
+
+def check_api_key():
+    """Check if OpenAI API key is configured"""
+    api_key = os.getenv("OPENAI_API_KEY")
+    if not api_key or api_key == "your_openai_api_key_here":
+        print("❌ OpenAI API key not configured!")
+        print("Please set your OPENAI_API_KEY in the .env file")
+        print("Get your API key from: https://platform.openai.com/api-keys")
+        return False
+    return True
+
+# Removed progress loading for now - focusing on core flow
+
+def get_user_input():
+    """Get topic and level from user"""
+    print("\n🎯 Let's start your learning journey!")
+    
+    # Get topic
+    while True:
+        topic = input("\nWhat topic would you like to study? ").strip()
+        if topic:
+            break
+        print("Please enter a valid topic")
+    
+    # Get level
+    print("\n📚 What's your current experience level?")
+    for i, level in enumerate(LEVELS, 1):
+        print(f"  {i}. {level.capitalize()}")
+    
+    while True:
+        try:
+            level_choice = int(input("Enter the number for your level: "))
+            if 1 <= level_choice <= len(LEVELS):
+                claimed_level = LEVELS[level_choice - 1]
+                break
+            else:
+                print("Please enter a valid number")
+        except ValueError:
+            print("Please enter a valid number")
+    
+    return topic, claimed_level
+
+def run_level_assessment(topic, claimed_level):
+    """Run level assessment for non-novice users"""
+    print(f"\n📝 Assessing your knowledge level for {topic}...")
+    print("This will help us create the perfect learning path for you.")
+    
+    try:
+        assessor = LevelAssessmentAgent()
+        actual_level = assessor.process(topic, claimed_level)
+        return actual_level
+    except Exception as e:
+        print(f"❌ Error during assessment: {e}")
+        print("⚠️  Defaulting to novice level")
+        return "novice"
+
+def generate_curriculum(topic, level):
+    """Generate curriculum for the topic and level"""
+    print(f"\n📚 Generating personalized curriculum for {topic} at {level} level...")
+    
+    try:
+        planner = CurriculumPlannerAgent()
+        curriculum = planner.process(topic, level)
+        print("✅ Curriculum generated successfully!")
+        return curriculum
+    except Exception as e:
+        print(f"❌ Error generating curriculum: {e}")
+        return None
+
+def main():
+    """Main application function - Core Learning Flow"""
+    print_banner()
+    
+    # Check API key
+    if not check_api_key():
+        return
+    
+    # Get user input for new session
+    topic, claimed_level = get_user_input()
+    user = UserState(topic=topic, claimed_level=claimed_level)
+    print(f"\n👤 User Profile: {user.topic} at {user.claimed_level} level")
+    
+    # Level assessment
+    if claimed_level == 'novice':
+        user.set_actual_level("novice")
+        print("✅ Skipping level assessment for novice users")
+    else:
+        actual_level = run_level_assessment(topic, claimed_level)
+        user.set_actual_level(actual_level)
+        print(f"✅ Assessment complete! Your level: {actual_level}")
+    
+    # Generate curriculum
+    curriculum = generate_curriculum(user.topic, user.actual_level)
+    if curriculum is None:
+        print("❌ Cannot proceed without curriculum")
+        return
+    
+    # Display curriculum
+    print("\n" + "="*60)
+    print("📖 YOUR PERSONALIZED CURRICULUM")
+    print("="*60)
+    curriculum.print_curriculum()
+    
+    # Start teaching
+    print(f"\n🚀 Starting your learning journey at {user.actual_level} level!")
+    print("The AI teacher will guide you through each module step by step.")
+    
+    try:
+        coordinator = CoordinatorAgent(user.actual_level, user)
+        coordinator.teach_curriculum(curriculum)
+        
+        # Final summary
+        print("\n" + "="*60)
+        print("🎉 LEARNING SESSION COMPLETE!")
+        print("="*60)
+        print("You've completed your learning journey!")
+        print("Great job on mastering the concepts! 🌟")
+        
+    except KeyboardInterrupt:
+        print("\n\n⏸️  Learning session stopped by user")
+        print("Thanks for learning with us!")
+    except Exception as e:
+        print(f"\n❌ Error during learning session: {e}")
+        print("Please try again or check your configuration.")
+    
+    print("\n👋 Thank you for using AI Teacher Bot!")
+    print("Keep learning and growing! 🌱")
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,4 @@
+gradio
+openai
+python-dotenv
+requests

user_state.py

@@ -0,0 +1,119 @@
+import json
+from datetime import datetime
+
+class UserState:
+    def __init__(self, topic=None, claimed_level=None):
+        self.topic = topic
+        self.claimed_level = claimed_level  # e.g., 'novice', 'intermediate', 'advanced'
+        self.actual_level = None  # Set after assessment
+        self.progress = {
+            'modules_completed': {},  # {chapter_name: {module_name: status}}
+            'chapters_completed': {},  # {chapter_name: completion_status}
+            'bloom_assessments': {},   # {chapter_name: assessment_results}
+            'overall_progress': {
+                'total_modules': 0,
+                'completed_modules': 0,
+                'total_chapters': 0,
+                'completed_chapters': 0,
+                'average_bloom_score': 0
+            },
+            'session_data': {
+                'start_time': datetime.now().isoformat(),
+                'last_activity': datetime.now().isoformat()
+            }
+        }
+
+    def set_actual_level(self, level):
+        self.actual_level = level
+
+    @property
+    def display_level(self):
+        """Returns the actual level if set, otherwise the claimed level"""
+        return self.actual_level or self.claimed_level
+
+    def update_module_progress(self, chapter_name, module_name, status="completed"):
+        """Update the completion status of a module"""
+        if chapter_name not in self.progress['modules_completed']:
+            self.progress['modules_completed'][chapter_name] = {}
+        
+        self.progress['modules_completed'][chapter_name][module_name] = {
+            'status': status,
+            'completed_at': datetime.now().isoformat()
+        }
+        self.progress['session_data']['last_activity'] = datetime.now().isoformat()
+
+    def update_chapter_progress(self, chapter_name, status="completed"):
+        """Update the completion status of a chapter"""
+        self.progress['chapters_completed'][chapter_name] = {
+            'status': status,
+            'completed_at': datetime.now().isoformat()
+        }
+        self.progress['session_data']['last_activity'] = datetime.now().isoformat()
+
+    def update_bloom_assessment(self, chapter_name, assessment_results):
+        """Store Bloom's assessment results for a chapter"""
+        # Store the assessment results directly without wrapping in 'results'
+        self.progress['bloom_assessments'][chapter_name] = assessment_results
+        self.progress['bloom_assessments'][chapter_name]['completed_at'] = datetime.now().isoformat()
+        self.progress['session_data']['last_activity'] = datetime.now().isoformat()
+
+    def calculate_overall_progress(self, curriculum):
+        """Calculate overall progress based on curriculum"""
+        total_modules = sum(len(chapter.modules) for chapter in curriculum.chapters)
+        completed_modules = sum(
+            len([m for m in modules.values() if m.get('status') == 'completed'])
+            for modules in self.progress['modules_completed'].values()
+        )
+        
+        total_chapters = len(curriculum.chapters)
+        completed_chapters = len([
+            c for c in self.progress['chapters_completed'].values() 
+            if c.get('status') == 'completed'
+        ])
+        
+        # Calculate average Bloom's score
+        bloom_scores = [
+            assessment.get('average_score', 0)
+            for assessment in self.progress['bloom_assessments'].values()
+        ]
+        average_bloom_score = sum(bloom_scores) / len(bloom_scores) if bloom_scores else 0
+        
+        self.progress['overall_progress'] = {
+            'total_modules': total_modules,
+            'completed_modules': completed_modules,
+            'total_chapters': total_chapters,
+            'completed_chapters': completed_chapters,
+            'average_bloom_score': average_bloom_score,
+            'completion_percentage': (completed_modules / total_modules * 100) if total_modules > 0 else 0
+        }
+
+    def get_progress_summary(self, curriculum=None):
+        """Get a formatted progress summary"""
+        if curriculum:
+            self.calculate_overall_progress(curriculum)
+        
+        overall = self.progress['overall_progress']
+        
+        summary = f"""
+PROGRESS SUMMARY
+===============
+Topic: {self.topic}
+Level: {self.actual_level or self.claimed_level}
+
+Overall Progress:
+- Modules: {overall['completed_modules']}/{overall['total_modules']} ({overall['completion_percentage']:.1f}%)
+- Chapters: {overall['completed_chapters']}/{overall['total_chapters']}
+- Average Bloom's Score: {overall['average_bloom_score']:.1f}/10
+
+Chapter Progress:
+"""
+        
+        for chapter_name, chapter_data in self.progress['chapters_completed'].items():
+            status = chapter_data.get('status', 'not_started')
+            summary += f"- {chapter_name}: {status}\n"
+        
+        return summary
+
+
+    def __repr__(self):
+        return f"UserState(topic={self.topic}, claimed_level={self.claimed_level}, actual_level={self.actual_level})"