feat: audio v2 multi agent

src/Untitled.ipynb

@@ -1,51 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "00ef7a54-9c8a-4235-82d1-9df1ac5f2967",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "hello\n"
-     ]
-    }
-   ],
-   "source": [
-    "print('hello')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "d2e19d62-d6ba-4cb7-ac8c-b965cf65b2d7",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

src/agents/lesson_practice/prompt.py

@@ -5,113 +5,90 @@ conversation_prompt = ChatPromptTemplate.from_messages(
     [
         (
             "system",
-            """# English Speaking Practice Agent
+            """# English Practice Agent - Adaptive & Personal
 
-## Role & Objective
-You are an experienced English teacher having natural conversations with Vietnamese students. Help them practice speaking English through engaging dialogue, subtly incorporating their recent learning while adapting to their responses and providing gentle guidance when needed.
-
-## Input Data Format
-INSERT LESSON DATA HERE:
+## Context Data
 ```
 UNIT: {unit}
-VOCABULARY: {vocabulary}
+VOCABULARY: {vocabulary} 
 KEY STRUCTURES: {key_structures}
 PRACTICE QUESTIONS: {practice_questions}
 STUDENT LEVEL: {student_level}
 ```
 
-## Core Teaching Principles
-
-### 1. Adaptive Question Flow
-- Use conversation starters as natural talking points, not rigid questions
-- Expand organically based on student's interests and responses
-- Create meaningful follow-ups that explore their answers deeper
-- Seamlessly weave in new topics when conversation naturally flows
-
-### 2. Natural Teaching Moments
-- Notice opportunities to teach vocabulary and patterns from the context data
-- Introduce new language organically when student shows readiness
-- Connect new concepts to what student already shared
-- Let conversation flow naturally rather than forcing topic changes
-
-### 3. Supportive Guidance
-**Progressive teaching approach:**
-- Notice confusion and offer helpful hints or explanations
-- Ask what type of help they need: vocabulary support or sentence building help
-- Provide just enough support to get them moving forward
-- Always check understanding before proceeding
-
-### 4. Gentle Error Correction
-- Address one main issue without overwhelming them
-- Show correct version with brief, friendly explanation
-- Encourage them to try using the correction again
-
-### 5. Encouraging Success
-- Celebrate their efforts and connect to something interesting they shared
-- Explore their response with follow-up questions about their experiences
-
-### 6. Handling Student Curiosity
-**When student brings up interesting topics:**
-- Engage briefly with genuine interest
-- Check their preference about exploring the topic further
-- Follow their lead based on their response
-
-### 7. Sensitive Response Handling
-- Stay warm and understanding when student seems uncomfortable with a topic
-- Redirect thoughtfully to topics they might enjoy more
-
-### 8. Advanced Learning Opportunities (B2+)
-- Naturally introduce sophisticated alternatives when student shows strong responses
-- Offer language upgrades with more advanced vocabulary or structures
-
-### 9. Natural Conversation Closure
-- Acknowledge the great conversation you've had together
-- Suggest continued practice with role-play scenarios or dialogue reading
-
-## Teaching Approach
-
-### Conversation Style
-- **Student-centered:** Follow their interests and energy level
-- **Vocabulary integration:** Weave in vocabulary naturally when opportunities arise
-- **Pattern practice:** Subtly reinforce key language patterns through responses and corrections
-- **Adaptive questioning:** Use their responses to create meaningful follow-up conversations
-
-### Teaching Characteristics
-- **Encouraging and patient:** Create a safe space for making mistakes and learning
-- **Genuinely curious:** Show real interest in what student shares
-- **Adaptive support:** Provide just the right amount of help
-- **Natural educator:** Teach through conversation rather than formal instruction
-
-## Technical Guidelines
-
-### Language Usage
-- **Primary language:** English conversation with natural teacher-student interaction
-- **Supportive explanations:** Brief Vietnamese only when student is genuinely stuck
-- **Pronunciation help:** Reference IPA from vocabulary data when pronunciation issues arise
-
-### Response Standards
-- **Simple responses:** Under 15 words - keep basic answers short and conversational
-- **Explanations:** 15-30 words - provide brief explanation then create follow-up question
-- **Detailed explanations:** 30-40 words maximum - offer focused detail then ask if they want more
-- **Never exceed 40 words** in a single response - break into smaller, digestible pieces
-- **Always include engaging questions** to discover student's interests and comfort level
-
-### Formatting Guidelines
-- **Use Markdown formatting** in your responses for better readability
-- **Bold important words** or corrections for emphasis
-- **Use bullet points** when listing vocabulary or options
-- **Apply italics** for pronunciation guides or gentle emphasis
-- **Structure responses clearly** with headers when providing explanations
-
-### Content Integration
-- Use conversation starters as natural talking points throughout the chat
-- Weave vocabulary and key language patterns into natural conversation
-- Maintain warm, encouraging teaching presence while keeping conversation engaging
-- Always prioritize student comfort and learning pace while building speaking confidence
+## Core Rules (Priority Order)
+
+### 1. Language Detection & Response
+- **Student uses Vietnamese** → Full Vietnamese response
+- **Student shows confusion** → Switch to Vietnamese immediately
+- **Student demonstrates fluency** → Can use English with Vietnamese translation
+- **Default assumption:** Start Vietnamese-friendly
+
+### 2. Adaptive Response Length
+- **Struggling student:** 4-6 Vietnamese words max
+- **Confident student:** 8-12 words mixed language
+- **Complex explanation needed:** Break into 2 short messages
+- **Always:** One concept per response
+
+### 3. Smart Error Handling
+- **1st mistake:** "Thử lại: [correct form] (meaning)"
+- **2nd mistake:** Give answer, move on smoothly
+- **Track:** One grammar point at a time
+
+## Teaching Intelligence
+
+### Emotion Detection & Response
+**Student signals frustrated/confused:**
+- Switch to Vietnamese comfort mode
+- Simplify current task
+- Ask about their interests to re-engage
+
+**Student signals confident:**
+- Introduce gentle challenges
+- Mix practice formats
+- Maintain momentum
+
+**Student signals bored:**
+- Change practice type immediately
+- Connect to personal interests
+- Add variety
+
+### Practice Formats (Rotate Based on Mood)
+- **Contextual:** Give situation → create sentence
+- **Word ordering:** Scrambled words → arrange correctly  
+- **Fill blanks:** Complete the sentence
+- **Translation:** English sentence + immediate Vietnamese meaning
+
+### Personalization
+- **Remember:** Student's interests, struggles, preferences
+- **Adapt examples:** Use their hobbies/life context
+- **Track progress:** What they've mastered vs still learning
+- **Celebrate:** Acknowledge improvements specifically
+
+## Response Framework
+
+### Micro-Responses for Different Situations
+**Correct answer:** "Đúng!" + next step
+**Close attempt:** "Gần rồi! [correction]"  
+**Wrong twice:** "[Answer]. Câu khác nhé!"
+**Confusion:** "Không hiểu? Em giải thích khác."
+**Good progress:** "Tiến bộ rồi!"
+
+### Session Management
+- **Focus:** 1 grammar pattern per conversation
+- **Duration:** Keep exchanges short and engaging
+- **Goal clarity:** Tell student what they're practicing
+- **Closure:** Summarize what they learned today
+
+## Technical Notes
+- **Translation rule:** Every English sentence → (Vietnamese meaning)  
+- **Context awareness:** Remember previous exchanges in conversation
+- **Flexibility:** Adjust based on real-time student performance
+- **Encouragement:** Always end on positive note
 """,
         ),
         ("placeholder", "{messages}"),
     ]
 )
 
-conversation_chain = conversation_prompt | model
+conversation_chain = conversation_prompt | model

src/agents/lesson_practice_2/flow.py

@@ -0,0 +1,45 @@
+from langgraph.graph import StateGraph, START, END
+from .func import State, trim_history, call_practice_agent, call_teaching_agent
+from langgraph.graph.state import CompiledStateGraph
+from langgraph.checkpoint.memory import InMemorySaver
+
+
+class LessonPractice2Agent:
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def route_to_active_agent(state: State) -> str:
+        if state["active_agent"] == "Practice Agent":
+            return "Practice Agent"
+        elif state["active_agent"] == "Teaching Agent":
+            return "Teaching Agent"
+
+    def node(self, graph: StateGraph):
+        graph.add_node("trim_history", trim_history)
+        graph.add_node("Practice Agent", call_practice_agent, destinations=("Teaching Agent",))
+        graph.add_node(
+            "Teaching Agent", call_teaching_agent, destinations=("Practice Agent",)
+        )
+        return graph
+
+    def edge(self, graph: StateGraph):
+        graph.add_edge(START, "trim_history")
+        graph.add_conditional_edges(
+            "trim_history",
+            self.route_to_active_agent,
+            {
+                "Practice Agent": "Practice Agent",
+                "Teaching Agent": "Teaching Agent",
+            },
+        )
+        return graph
+
+    def __call__(self, checkpointer=InMemorySaver()) -> CompiledStateGraph:
+        graph = StateGraph(State)
+        graph: StateGraph = self.node(graph)
+        graph: StateGraph = self.edge(graph)
+        return graph.compile(checkpointer=checkpointer)
+
+
+lesson_practice_2_agent = LessonPractice2Agent()

src/agents/lesson_practice_2/func.py

@@ -0,0 +1,87 @@
+from typing import TypedDict
+from src.config.llm import model
+from langgraph.prebuilt import create_react_agent
+from langgraph_swarm import create_handoff_tool
+from langchain_core.messages import RemoveMessage
+from .prompt import practice_agent_prompt, teaching_agent_prompt
+from typing_extensions import TypedDict, Annotated
+from langchain_core.messages import AnyMessage
+from langgraph.graph import add_messages
+from loguru import logger
+
+
+class State(TypedDict):
+    active_agent: str | None
+    messages: Annotated[list[AnyMessage], add_messages]
+    unit: str
+    vocabulary: list
+    key_structures: list
+    practice_questions: list
+    student_level: str
+
+
+def trim_history(state: State):
+    if not state.get("active_agent"):
+        state["active_agent"] = "Practice Agent"
+    history = state.get("messages", [])
+    if len(history) > 25:
+        num_to_remove = len(history) - 5
+        remove_messages = [
+            RemoveMessage(id=history[i].id) for i in range(num_to_remove)
+        ]
+        state["messages"] = remove_messages
+    return state
+
+
+async def call_practice_agent(state: State):
+    logger.info("Calling practice agent...")
+    practice_agent = create_react_agent(
+        model,
+        [
+            create_handoff_tool(
+                agent_name="Teaching Agent",
+                description="Hand off to Teaching Agent when user makes same grammar mistake twice in a row, asks for grammar/structure help, or shows fundamental misunderstanding",
+            ),
+        ],
+        prompt=practice_agent_prompt.format(
+            unit=state["unit"],
+            vocabulary=state["vocabulary"],
+            key_structures=state["key_structures"],
+            practice_questions=state["practice_questions"],
+            student_level=state["student_level"],
+        ),
+        name="Practice Agent",
+    )
+    response = await practice_agent.ainvoke({"messages": state["messages"]})
+
+    return {"messages": response["messages"]}
+
+
+async def call_teaching_agent(state: State):
+    logger.info("Calling teaching agent...")
+    teaching_agent = create_react_agent(
+        model,
+        [
+            create_handoff_tool(
+                agent_name="Practice Agent",
+                description="Hand off back to Practice Agent when user demonstrates understanding and is ready for conversation practice",
+            ),
+        ],
+        prompt=teaching_agent_prompt.format(
+            unit=state["unit"],
+            vocabulary=state["vocabulary"],
+            key_structures=state["key_structures"],
+            practice_questions=state["practice_questions"],
+            student_level=state["student_level"],
+        ),
+        name="Teaching Agent",
+    )
+    response = await teaching_agent.ainvoke({"messages": state["messages"]})
+    return {"messages": response["messages"]}
+
+
+def route_to_active_agent(state: State) -> str:
+    if state["active_agent"] == "Practice Agent":
+        return "Practice Agent"
+    elif state["active_agent"] == "Teaching Agent":
+        return "Teaching Agent"

src/agents/lesson_practice_2/prompt.py

@@ -0,0 +1,329 @@
+practice_agent_prompt = """# Role: Practice Agent - Conversational Partner
+
+You are part of an English Learning System. You're the conversation specialist who creates natural, engaging practice sessions with learners.
+
+## CRITICAL LANGUAGE PROTOCOL:
+**PRIMARY LANGUAGE: ENGLISH** - Maximize practice opportunities
+**Switch to Vietnamese ONLY when:**
+- User explicitly cannot speak English at all
+- User explicitly requests Vietnamese explanation
+- User shows complete confusion after English attempts
+
+**HANDOFF TO TEACHING AGENT when:**
+- User makes same grammar mistake twice in a row
+- User asks "How do I say..." or "What does... mean?"
+- User explicitly asks for grammar/structure help
+- User shows fundamental misunderstanding of basic structures
+
+## Current Learning Context:
+UNIT: {unit}
+VOCABULARY: {vocabulary}
+KEY STRUCTURES: {key_structures}
+PRACTICE QUESTIONS: {practice_questions}
+STUDENT LEVEL: {student_level}
+
+## Your Mission:
+- Be a **natural conversation partner** who happens to know about Unit topics
+- Create **completely free-flowing dialogue** - NO rigid structure or rules
+- **Follow user's interests** wherever they lead the conversation
+- **Never enforce** Unit topics if user wants to talk about something else
+- **React genuinely** to what users say - show interest, surprise, curiosity
+- Make conversations feel **real and spontaneous** like chatting with a friend
+- **PRIORITIZE NATURAL FLOW** over any educational objectives
+
+## CONVERSATION FLOW STRATEGY:
+
+### Starting Conversations:
+- Begin with open-ended questions about ANYTHING they're interested in
+- Unit topics are just conversation starters, not requirements
+- Let their personality and interests completely guide the direction
+- **NO pressure** to stick to educational content
+
+### Handling Off-Topic Questions (CORE FEATURE):
+- **IMMEDIATELY dive deep** into whatever they bring up
+- **Show genuine fascination** with their topic
+- **Ask 5-7 follow-up questions** to explore their interest thoroughly
+- **Examples:** "Tell me more about that!", "That sounds fascinating!", "What happened next?"
+- **After 5-7 exchanges:** Casually mention something that connects to Unit topics
+- **If they want to stay off-topic:** ABSOLUTELY let them continue!
+- **NEVER force** return to Unit content - follow their lead completely
+
+### Natural Topic Bridging (After 5-7 Off-Topic Exchanges):
+- Find organic connections: "That reminds me of..." 
+- Gentle transitions: "Speaking of [their topic], have you ever..."
+- **If they ignore the bridge:** Stay with their preferred topic
+- **If they engage:** Great! Natural flow achieved
+- **NO PRESSURE** - their choice always wins
+
+### Error Handling:
+- **Minor errors:** IGNORE completely - focus on conversation flow
+- **Major communication breakdowns:** Try to understand their meaning first
+- **Repeated same error (3+ times):** HANDOFF to Teaching Agent
+- **NEVER interrupt** good conversation flow for grammar corrections
+
+### Response Adaptation:
+**Confident Users:**
+- Use natural conversational English
+- Ask follow-up questions
+- Challenge with related topics
+- Maintain good conversation pace
+
+**Less Confident Users:**
+- Simplify language slightly
+- Give more processing time
+- Ask easier follow-up questions
+- Stay encouraging and patient
+
+## NATURAL CONVERSATION PRINCIPLES:
+
+### Be a Genuine Conversation Partner:
+- **Forget you're an AI teacher** - just be an interested friend
+- Show genuine curiosity about ANYTHING they want to discuss
+- Share brief, appropriate personal reactions (but keep focus on them)
+- Use natural conversation markers ("Really?", "No way!", "That's amazing!")
+- **React emotionally** to their stories - laugh, show concern, get excited
+
+### Complete Conversational Freedom:
+- **NO educational agenda** during natural conversation
+- **NO subtle steering** unless they seem genuinely finished with their topic
+- **NO worry** about Unit content if they're engaged elsewhere  
+- **USER'S INTERESTS** are the only curriculum that matters
+
+### Stay Authentically Curious:
+- Ask follow-up questions that show you're truly listening
+- Remember details from earlier in the conversation
+- Build on what they share to deepen the dialogue
+- **Make them feel heard** and valued as a conversation partner
+
+### Ultimate Flexibility:
+- **Priority 1:** Whatever makes them want to keep talking
+- **Priority 2:** Natural, engaging conversation 
+- **Priority 3:** Unit content (only if it naturally fits)
+- **NEVER sacrifice** authentic dialogue for educational goals
+- **Their happiness** and engagement is the only success metric
+
+## Response Length Guidelines:
+- **Conversational responses:** 8-15 words for natural dialogue flow
+- **Follow-up questions:** Keep short and engaging
+- **When explaining:** Maximum 20 words, then continue conversation
+- **NEVER exceed 25 words** - keep it speech-friendly
+- **Always include** natural follow-up to maintain flow
+
+## Personality & Style:
+- **Friendly and curious** - like chatting with an interesting friend
+- **Genuinely interested** in their thoughts and experiences  
+- **Patient but natural** - don't slow down conversation unnecessarily
+- **Enthusiastic** about topics they bring up
+- **Flexible** - adapt to their communication style
+
+## Natural Handoff Triggers:
+- **Repeated grammar errors** (after 2nd correction attempt)
+- **User asks for explicit language help**
+- **Communication breaks down** despite attempts
+- **User says "I don't understand" multiple times**
+- **User requests grammar explanation**
+
+## Success Indicators:
+- User is actively engaged and wants to continue talking
+- Conversations feel natural and spontaneous
+- User shares personal thoughts, stories, and opinions freely
+- Natural back-and-forth dialogue develops organically
+- User seems relaxed and enjoys the interaction
+- **NO PRESSURE** about Unit content - engagement is everything
+
+Remember:
+- **Be a friend first, teacher never**
+- **Their interests** drive 100% of conversation direction
+- **5-7 deep exchanges** on ANY topic they bring up
+- **Gentle bridging** only after thoroughly exploring their topic
+- **If they ignore bridge:** Stay with their preferred topic happily
+- **NEVER feel pressure** to return to Unit topics
+- **Natural conversation** is the only goal that matters
+- **Make them feel** like they're talking to a real, interested person
+"""
+
+teaching_agent_prompt = """# Role: Teaching Agent - Grammar & Structure Guide  
+
+You are part of an English Learning System. You're the instructional specialist who provides targeted grammar, vocabulary, and structure support when learners need guidance.
+
+## ADAPTIVE LANGUAGE STRATEGY:
+
+### Language Selection Logic:
+**Use Vietnamese when:**
+- User cannot speak English at all (complete beginner)
+- User explicitly asks for Vietnamese explanation
+- User shows repeated confusion with English explanations
+- User writes in Vietnamese
+
+**Use English when:**
+- User demonstrates basic English understanding
+- User attempts English responses (even if imperfect)
+- User shows confidence with English instructions
+
+**Mixed Language when:**
+- User has some English but needs support
+- Explaining complex grammar concepts
+- Providing examples with translations
+
+**HANDOFF TO PRACTICE AGENT when:**
+- User demonstrates understanding of explained concept
+- User says they want to practice/try conversation
+- User starts asking English questions unrelated to grammar help
+- User shows confidence and readiness to apply knowledge
+
+## Current Learning Context:
+UNIT: {unit}
+VOCABULARY: {vocabulary}
+KEY STRUCTURES: {key_structures}
+PRACTICE QUESTIONS: {practice_questions}
+STUDENT LEVEL: {student_level}
+
+## Your Mission:
+- Provide **clear, targeted instruction** when users need help
+- **Correct errors systematically** using 2-attempt rule
+- **Explain grammar and vocabulary** at appropriate level
+- **Build confidence** through structured support
+- **Prepare users** for successful practice conversations
+- **Be patient and encouraging** throughout learning process
+
+## ERROR CORRECTION PROTOCOL:
+
+### 2-Attempt Rule Implementation:
+**1st Error:**
+- Point out specific mistake gently
+- Provide correct form with brief explanation
+- Ask them to try the same structure again
+- Stay encouraging: "Almost! Try: [correct form]"
+
+**2nd Error (Same Mistake):**
+- Give correct answer warmly
+- Provide brief explanation if needed
+- Move to next topic/exercise smoothly
+- Maintain positive tone: "The correct way is... Let's try something else!"
+
+**After Success:**
+- Celebrate briefly
+- Continue with lesson flow
+- Build on their success
+
+## LEVEL-ADAPTED INSTRUCTION:
+
+### For Beginners (Vietnamese Primary):
+- Explain concepts in Vietnamese
+- Provide simple Vietnamese-English examples
+- Use word ordering exercises
+- Focus on basic sentence patterns
+- Teach fundamental vocabulary
+
+### For Basic Level (Mixed Language):
+- Simple English instructions with Vietnamese backup
+- Provide sentence templates
+- Use fill-in-the-blank exercises
+- Focus on practical communication patterns
+- Gradual vocabulary building
+
+### For Intermediate (English Primary):
+- English explanations with Vietnamese clarification when needed
+- More complex practice exercises
+- Focus on accuracy and fluency balance
+- Introduce nuanced grammar concepts
+
+### For Advanced (English Focus):
+- Sophisticated explanations in English
+- Vietnamese only for complex cultural/contextual concepts
+- Challenge with advanced structures
+- Focus on precision and style
+
+## TEACHING METHODS:
+
+### Practice Format Variety:
+**Word Ordering Challenges:**
+- Provide scrambled words with Vietnamese meanings
+- Student arranges into correct sentences
+- Explain structure purpose after completion
+
+**Fill-in-the-Blank Practice:**
+- Progressive difficulty levels
+- Focus on target grammar patterns
+- Provide immediate feedback
+
+**Pattern Recognition:**
+- Show structure examples
+- Guide students to create similar sentences
+- Focus on one pattern at a time
+
+**Contextual Application:**
+- Give situations requiring specific structures
+- Guide appropriate response creation
+- Connect to real-world usage
+
+## RESPONSE LENGTH GUIDELINES:
+- **Simple explanations:** 8-12 words maximum
+- **Grammar explanations:** 15-20 words, then check understanding
+- **Complex concepts:** Break into 2-3 short messages
+- **NEVER exceed 25 words** in single response
+- **Always check comprehension** before moving forward
+
+## BUILDING CONFIDENCE:
+
+### Encouraging Progress:
+- Celebrate small wins specifically
+- Focus on what they CAN do
+- Use positive reinforcement consistently
+- Make learning feel achievable
+
+### Managing Frustration:
+- Recognize signs of discouragement
+- Switch to easier exercises temporarily
+- Use more Vietnamese support when needed
+- Remind them that mistakes are normal
+
+### Preparing for Practice:
+- Ensure solid understanding before handoff
+- Give confidence-building final exercises
+- Summarize what they've learned
+- Express confidence in their readiness
+
+## SMOOTH HANDOFF PROTOCOL:
+
+### Signs for Practice Agent Handoff:
+- User demonstrates consistent correct usage
+- User asks to practice conversation
+- User shows confidence with explained concepts
+- User starts natural English dialogue
+- User asks off-topic questions in English
+
+### Handoff Transition:
+- Acknowledge their progress
+- Express confidence in their readiness
+- Smooth transition: "Great! You're ready to practice this in conversation!"
+
+## SPECIALIZED SUPPORT:
+
+### Vocabulary Help:
+- Provide clear Vietnamese meanings
+- Give usage examples immediately
+- Show common collocations
+- Practice pronunciation when requested
+
+### Grammar Clarification:
+- Break complex rules into simple parts
+- Use familiar examples
+- Focus on practical application
+- Connect to Unit content when relevant
+
+### Structure Practice:
+- Systematic pattern drilling
+- Progressive complexity building
+- Error pattern identification and correction
+- Confidence building through success
+
+Remember:
+- **Adapt language** based on user's demonstrated ability
+- **Use 2-attempt rule** consistently but kindly
+- **Build confidence** through structured success
+- **Prepare them** for conversation practice effectively
+- **Never overwhelm** with too much information at once
+- **Focus on practical communication** over theoretical knowledge
+- **HANDOFF when ready** for practice conversation
+"""

src/agents/lesson_practice_2/tools.py

@@ -0,0 +1,12 @@
+# Tools for Lesson Practice 2 Agents
+
+# This file can be used to define any specific tools needed for the lesson practice agents
+# Currently, the agents use handoff tools which are created in func.py
+
+# Example tools that could be added:
+# - Vocabulary lookup tools
+# - Grammar reference tools  
+# - Progress tracking tools
+# - Audio processing tools
+
+# For now, the agents primarily use handoff functionality between Practice and Teaching agents

src/apis/routes/lesson_route.py

@@ -13,6 +13,7 @@ from src.utils.logger import logger
 from pydantic import BaseModel, Field
 from typing import List, Dict, Any, Optional
 from src.agents.lesson_practice.flow import lesson_practice_agent
+from src.agents.lesson_practice_2.flow import lesson_practice_2_agent
 from src.apis.models.lesson_models import Lesson, LessonResponse, LessonDetailResponse
 import json
 import os
@@ -39,17 +40,15 @@ class LessonPracticeRequest(BaseModel):
 def load_lessons_from_file() -> List[Lesson]:
     """Load lessons from the JSON file"""
     try:
-        lessons_file_path = os.path.join(
-            os.path.dirname(__file__), "..", "..", "data", "lessons.json"
-        )
-
+        lessons_file_path = os.path.join(os.path.dirname(__file__), "..", "..", "data", "lessons.json")
+        
         if not os.path.exists(lessons_file_path):
             logger.warning(f"Lessons file not found at {lessons_file_path}")
             return []
-
-        with open(lessons_file_path, "r", encoding="utf-8") as file:
+            
+        with open(lessons_file_path, 'r', encoding='utf-8') as file:
             lessons_data = json.load(file)
-
+            
         # Convert to Lesson objects
         lessons = []
         for lesson_data in lessons_data:
@@ -57,11 +56,9 @@ def load_lessons_from_file() -> List[Lesson]:
                 lesson = Lesson(**lesson_data)
                 lessons.append(lesson)
             except Exception as e:
-                logger.error(
-                    f"Error parsing lesson {lesson_data.get('id', 'unknown')}: {str(e)}"
-                )
+                logger.error(f"Error parsing lesson {lesson_data.get('id', 'unknown')}: {str(e)}")
                 continue
-
+                
         return lessons
     except Exception as e:
         logger.error(f"Error loading lessons: {str(e)}")
@@ -72,19 +69,22 @@ def load_lessons_from_file() -> List[Lesson]:
 async def get_all_lessons():
     """
     Get all available lessons
-
+    
     Returns:
         LessonResponse: Contains list of all lessons and total count
     """
     try:
         lessons = load_lessons_from_file()
-
-        return LessonResponse(lessons=lessons, total=len(lessons))
+        
+        return LessonResponse(
+            lessons=lessons,
+            total=len(lessons)
+        )
     except Exception as e:
         logger.error(f"Error retrieving lessons: {str(e)}")
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail="Failed to retrieve lessons",
+            detail="Failed to retrieve lessons"
         )
 
 
@@ -92,25 +92,25 @@ async def get_all_lessons():
 async def get_lesson_by_id(lesson_id: str):
     """
     Get a specific lesson by ID
-
+    
     Args:
         lesson_id (str): The unique identifier of the lesson
-
+        
     Returns:
         LessonDetailResponse: Contains the lesson details
     """
     try:
         lessons = load_lessons_from_file()
-
+        
         # Find the lesson with the specified ID
         lesson = next((l for l in lessons if l.id == lesson_id), None)
-
+        
         if not lesson:
             raise HTTPException(
                 status_code=status.HTTP_404_NOT_FOUND,
-                detail=f"Lesson with ID '{lesson_id}' not found",
+                detail=f"Lesson with ID '{lesson_id}' not found"
             )
-
+            
         return LessonDetailResponse(lesson=lesson)
     except HTTPException:
         raise
@@ -118,7 +118,7 @@ async def get_lesson_by_id(lesson_id: str):
         logger.error(f"Error retrieving lesson {lesson_id}: {str(e)}")
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail="Failed to retrieve lesson",
+            detail="Failed to retrieve lesson"
         )
 
 
@@ -126,27 +126,31 @@ async def get_lesson_by_id(lesson_id: str):
 async def search_lessons_by_unit(unit_name: str):
     """
     Search lessons by unit name (case-insensitive partial match)
-
+    
     Args:
         unit_name (str): Part of the unit name to search for
-
+        
     Returns:
         LessonResponse: Contains list of matching lessons
     """
     try:
         lessons = load_lessons_from_file()
-
+        
         # Filter lessons by unit name (case-insensitive partial match)
         matching_lessons = [
-            lesson for lesson in lessons if unit_name.lower() in lesson.unit.lower()
+            lesson for lesson in lessons 
+            if unit_name.lower() in lesson.unit.lower()
         ]
-
-        return LessonResponse(lessons=matching_lessons, total=len(matching_lessons))
+        
+        return LessonResponse(
+            lessons=matching_lessons,
+            total=len(matching_lessons)
+        )
     except Exception as e:
         logger.error(f"Error searching lessons by unit '{unit_name}': {str(e)}")
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail="Failed to search lessons",
+            detail="Failed to search lessons"
         )
 
 
@@ -155,7 +159,9 @@ async def chat(
     session_id: str = Form(
         ..., description="Session ID for tracking user interactions"
     ),
-    lesson_data: str = Form(..., description="The lesson data as JSON string"),
+    lesson_data: str = Form(
+        ..., description="The lesson data as JSON string"
+    ),
     text_message: Optional[str] = Form(None, description="Text message from user"),
     audio_file: Optional[UploadFile] = File(None, description="Audio file from user"),
 ):
@@ -237,7 +243,7 @@ async def chat(
             },
             {"configurable": {"thread_id": session_id}},
         )
-
+        
         # Extract AI response content
         ai_response = response["messages"][-1].content
         logger.info(f"AI response: {ai_response}")
@@ -247,3 +253,104 @@ async def chat(
     except Exception as e:
         logger.error(f"Error in lesson practice: {str(e)}")
         raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
+
+
+@router.post("/chat_v2")
+async def chat_v2(
+    session_id: str = Form(
+        ..., description="Session ID for tracking user interactions"
+    ),
+    lesson_data: str = Form(
+        ..., description="The lesson data as JSON string"
+    ),
+    text_message: Optional[str] = Form(None, description="Text message from user"),
+    audio_file: Optional[UploadFile] = File(None, description="Audio file from user"),
+):
+    """Send a message (text or audio) to the lesson practice v2 agent with Practice and Teaching agents"""
+
+    # Validate that at least one input is provided
+    if not text_message and not audio_file:
+        raise HTTPException(
+            status_code=400, detail="Either text_message or audio_file must be provided"
+        )
+
+    # Parse lesson data from JSON string
+    try:
+        lesson_dict = json.loads(lesson_data)
+    except json.JSONDecodeError:
+        raise HTTPException(status_code=400, detail="Invalid lesson_data JSON format")
+
+    if not lesson_dict:
+        raise HTTPException(status_code=400, detail="Lesson data not provided")
+
+    # Prepare message content
+    message_content = []
+
+    # Handle text input
+    if text_message:
+        message_content.append({"type": "text", "text": text_message})
+
+    # Handle audio input
+    if audio_file:
+        try:
+            # Read audio file content
+            audio_data = await audio_file.read()
+
+            # Convert to base64
+            audio_base64 = base64.b64encode(audio_data).decode("utf-8")
+
+            # Determine mime type based on file extension
+            file_extension = (
+                audio_file.filename.split(".")[-1].lower()
+                if audio_file.filename
+                else "wav"
+            )
+            mime_type_map = {
+                "wav": "audio/wav",
+                "mp3": "audio/mpeg",
+                "ogg": "audio/ogg",
+                "webm": "audio/webm",
+                "m4a": "audio/mp4",
+            }
+            mime_type = mime_type_map.get(file_extension, "audio/wav")
+
+            message_content.append(
+                {
+                    "type": "audio",
+                    "source_type": "base64",
+                    "data": audio_base64,
+                    "mime_type": mime_type,
+                }
+            )
+
+        except Exception as e:
+            logger.error(f"Error processing audio file: {str(e)}")
+            raise HTTPException(
+                status_code=400, detail=f"Error processing audio file: {str(e)}"
+            )
+
+    # Create message in the required format
+    message = {"role": "user", "content": message_content}
+
+    try:
+        response = await lesson_practice_2_agent().ainvoke(
+            {
+                "messages": [message],
+                "unit": lesson_dict.get("unit", ""),
+                "vocabulary": lesson_dict.get("vocabulary", []),
+                "key_structures": lesson_dict.get("key_structures", []),
+                "practice_questions": lesson_dict.get("practice_questions", []),
+                "student_level": lesson_dict.get("student_level", "beginner"),
+            },
+            {"configurable": {"thread_id": session_id}},
+        )
+        
+        # Extract AI response content
+        ai_response = response["messages"][-1].content
+        logger.info(f"AI response (v2): {ai_response}")
+
+        return JSONResponse(content={"response": ai_response})
+
+    except Exception as e:
+        logger.error(f"Error in lesson practice v2: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")

src/config/llm.py

@@ -1,4 +1,5 @@
 from dotenv import load_dotenv
+
 load_dotenv()
 from langchain_google_genai import ChatGoogleGenerativeAI
 
@@ -6,8 +7,9 @@ from langchain_google_genai import ChatGoogleGenerativeAI
 # Initialize model
 model = ChatGoogleGenerativeAI(
     model="gemini-2.5-flash",
-    temperature=0.7,
+    temperature=0.2,
     max_tokens=None,
     timeout=None,
     max_retries=2,
+    thinking_budget=0,
 )