feat: evaluation when end

src/agents/evaluation/agent.py

@@ -0,0 +1,163 @@
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.pydantic_v1 import BaseModel, Field
+from src.config.llm import model
+from src.utils.logger import logger
+from .prompt import evaluation_prompt
+from langgraph.checkpoint.memory import InMemorySaver
+from typing import List, Dict, Any
+from src.agents.role_play.flow import role_play_agent
+
+
+# Define the structured output format
+class ResponseFormatter(BaseModel):
+    """Structured output format for conversation evaluation"""
+
+    score: int = Field(
+        ..., description="Overall conversation score out of 100", ge=0, le=100
+    )
+    feedback: str = Field(..., description="Overall feedback summary")
+    strengths: List[str] = Field(..., description="List of conversation strengths")
+    improvements: List[str] = Field(..., description="List of areas for improvement")
+    suggestions: List[str] = Field(
+        ..., description="List of specific improvement suggestions"
+    )
+    next_steps: List[str] = Field(..., description="List of recommended next steps")
+
+
+# Create the prompt template
+
+
+async def evaluate_conversation(
+    session_id: str,
+    learner_level: str = "beginner",
+    scenario_title: str = "",
+    scenario_description: str = "",
+    key_vocabulary: str = "",
+) -> Dict[str, Any]:
+    """
+    Evaluate a conversation based on the session ID and provide feedback.
+
+    Args:
+        session_id: The thread ID for the conversation
+        learner_level: The English level of the learner
+        scenario_title: Title of the conversation scenario
+        scenario_description: Description of the conversation scenario
+        key_vocabulary: Key vocabulary words from the scenario
+
+    Returns:
+        Dict containing evaluation results including score and feedback
+    """
+    logger.info(f"Evaluating conversation for session_id: {session_id}")
+    config = {"configurable": {"thread_id": session_id}}
+    snapshot = await role_play_agent().aget_state(config)
+    messages = snapshot.values.get("messages", [])
+    if not messages:
+        return {
+            "score": 0,
+            "feedback": "No conversation found for this session.",
+            "strengths": [],
+            "improvements": [],
+            "suggestions": [],
+            "next_steps": [],
+        }
+
+    evaluation_prompt_template = ChatPromptTemplate.from_messages(
+        [
+            (
+                "system",
+                """# CONVERSATION EVALUATOR - English Learning Assessment Specialist
+
+You are **WISE Evaluator**, an expert English tutor who analyzes conversations between learners and AI roleplay partners. Your job is to provide comprehensive feedback that helps learners improve.
+
+## Evaluation Context
+- **Session ID**: {session_id}
+- **Learner Level**: {learner_level}
+- **Scenario**: {scenario_title} - {scenario_description}
+- **Key Vocabulary**: {key_vocabulary}
+
+## Your Evaluation Mission
+1. **Score the conversation** (0-100 scale) based on fluency, accuracy, and engagement
+2. **Identify strengths** - What did the learner do well?
+3. **Pinpoint areas for improvement** - Where can they get better?
+4. **Provide specific suggestions** - Concrete actions for improvement
+5. **Recommend next steps** - What should they practice next?
+
+## Scoring Criteria
+
+### Fluency (30 points)
+- **Flow**: How naturally does the conversation progress?
+- **Response time**: Are there appropriate pauses or unnatural delays?
+- **Turn-taking**: Good balance of speaking between learner and AI?
+
+### Accuracy (30 points)
+- **Grammar**: Correct sentence structures and verb forms
+- **Vocabulary**: Appropriate word choices and usage
+- **Pronunciation**: (If audio available) Clear pronunciation of words
+
+### Engagement (20 points)
+- **Relevance**: Staying on topic and scenario context
+- **Interaction**: Active participation and questions
+- **Creativity**: Bringing personal experiences or unique responses
+
+### Vocabulary Usage (20 points)
+- **Range**: Using diverse vocabulary from the scenario
+- **Accuracy**: Correct usage of key vocabulary words
+- **Complexity**: Appropriate challenge level for learner
+
+## Response Format Requirements
+
+You must provide your response in the following structured format:
+
+### SCORE: [X/100]
+Provide a single overall score out of 100.
+
+### STRENGTHS:
+List specific strengths the learner demonstrated in the conversation.
+
+### AREAS FOR IMPROVEMENT:
+List specific areas where the learner can improve.
+
+### IMPROVEMENT SUGGESTIONS:
+Provide concrete, actionable suggestions for improvement with examples.
+
+### NEXT STEPS:
+Recommend specific next steps for continued learning and practice.
+
+## Important Guidelines:
+- **Be encouraging**: Focus on growth, not just mistakes
+- **Be specific**: Give concrete examples, not vague advice
+- **Be appropriate**: Match feedback complexity to learner level
+- **Be actionable**: Every suggestion should be something they can practice
+- **Use markdown**: Structure feedback clearly with headers and bullet points
+
+Remember: Your goal is to help learners feel motivated while giving them clear paths to improvement. Balance honest feedback with positive reinforcement.
+""",
+            ),
+            ("placeholder", "{messages}"),
+        ]
+    )
+    chain = evaluation_prompt_template | model.with_structured_output(ResponseFormatter)
+
+    # Call the LLM with the formatted prompt
+    structured_output: ResponseFormatter = await chain.ainvoke(
+        {
+            "session_id": session_id,
+            "learner_level": learner_level,
+            "scenario_title": scenario_title,
+            "scenario_description": scenario_description,
+            "key_vocabulary": key_vocabulary,
+            "messages": messages,
+        }
+    )
+
+    # Convert structured output to dictionary
+    result = {
+        "score": structured_output.score,
+        "feedback": structured_output.feedback,
+        "strengths": structured_output.strengths,
+        "improvements": structured_output.improvements,
+        "suggestions": structured_output.suggestions,
+        "next_steps": structured_output.next_steps,
+    }
+
+    return result

src/agents/evaluation/prompt.py

@@ -0,0 +1,67 @@
+evaluation_prompt = """# CONVERSATION EVALUATOR - English Learning Assessment Specialist
+
+You are **WISE Evaluator**, an expert English tutor who analyzes conversations between learners and AI roleplay partners. Your job is to provide comprehensive feedback that helps learners improve.
+
+## Evaluation Context
+- **Session ID**: {session_id}
+- **Learner Level**: {learner_level}
+- **Scenario**: {scenario_title} - {scenario_description}
+- **Key Vocabulary**: {key_vocabulary}
+
+## Your Evaluation Mission
+1. **Score the conversation** (0-100 scale) based on fluency, accuracy, and engagement
+2. **Identify strengths** - What did the learner do well?
+3. **Pinpoint areas for improvement** - Where can they get better?
+4. **Provide specific suggestions** - Concrete actions for improvement
+5. **Recommend next steps** - What should they practice next?
+
+## Scoring Criteria
+
+### Fluency (30 points)
+- **Flow**: How naturally does the conversation progress?
+- **Response time**: Are there appropriate pauses or unnatural delays?
+- **Turn-taking**: Good balance of speaking between learner and AI?
+
+### Accuracy (30 points)
+- **Grammar**: Correct sentence structures and verb forms
+- **Vocabulary**: Appropriate word choices and usage
+- **Pronunciation**: (If audio available) Clear pronunciation of words
+
+### Engagement (20 points)
+- **Relevance**: Staying on topic and scenario context
+- **Interaction**: Active participation and questions
+- **Creativity**: Bringing personal experiences or unique responses
+
+### Vocabulary Usage (20 points)
+- **Range**: Using diverse vocabulary from the scenario
+- **Accuracy**: Correct usage of key vocabulary words
+- **Complexity**: Appropriate challenge level for learner
+
+## Response Format Requirements
+
+You must provide your response in the following structured format:
+
+### SCORE: [X/100]
+Provide a single overall score out of 100.
+
+### STRENGTHS:
+List specific strengths the learner demonstrated in the conversation.
+
+### AREAS FOR IMPROVEMENT:
+List specific areas where the learner can improve.
+
+### IMPROVEMENT SUGGESTIONS:
+Provide concrete, actionable suggestions for improvement with examples.
+
+### NEXT STEPS:
+Recommend specific next steps for continued learning and practice.
+
+## Important Guidelines:
+- **Be encouraging**: Focus on growth, not just mistakes
+- **Be specific**: Give concrete examples, not vague advice
+- **Be appropriate**: Match feedback complexity to learner level
+- **Be actionable**: Every suggestion should be something they can practice
+- **Use markdown**: Structure feedback clearly with headers and bullet points
+
+Remember: Your goal is to help learners feel motivated while giving them clear paths to improvement. Balance honest feedback with positive reinforcement.
+"""

src/agents/lesson_practice/flow.py

@@ -1,41 +0,0 @@
-from langgraph.graph import StateGraph, START, END
-from .func import State, trim_history, agent, tool_node
-from langgraph.graph.state import CompiledStateGraph
-from langgraph.checkpoint.memory import InMemorySaver
-
-
-class LessonPracticeAgent:
-    def __init__(self):
-        pass
-
-    @staticmethod
-    def should_continue(state: State):
-        messages = state["messages"]
-        last_message = messages[-1]
-        if not last_message.tool_calls:
-            return "end"
-        else:
-            return "continue"
-
-    def node(self, graph: StateGraph):
-        graph.add_node("trim_history", trim_history)
-        graph.add_node("agent", agent)
-        graph.add_node("tools", tool_node)
-        return graph
-
-    def edge(self, graph: StateGraph):
-        graph.add_edge(START, "trim_history")
-        graph.add_edge("trim_history", "agent")
-        graph.add_conditional_edges(
-            "agent", self.should_continue, {"end": END, "continue": "tools"}
-        )
-        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_agent = LessonPracticeAgent()

src/agents/lesson_practice/func.py

@@ -1,60 +0,0 @@
-from typing import (
-    Annotated,
-    Sequence,
-    TypedDict,
-)
-from langchain_core.messages import ToolMessage, AnyMessage, RemoveMessage
-from langgraph.graph.message import add_messages
-import json
-from .prompt import conversation_prompt
-from src.config.llm import model
-
-
-class State(TypedDict):
-    """The state of the agent."""
-
-    unit: str
-    vocabulary: list
-    key_structures: list
-    practice_questions: list
-    student_level: list
-    messages: Annotated[Sequence[AnyMessage], add_messages]
-
-
-tools = []
-
-tools_by_name = {tool.name: tool for tool in tools}
-
-
-def trim_history(state: State):
-    if not state.get("active_agent"):
-        state["active_agent"] = "Roleplay 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
-
-
-# Define our tool node
-def tool_node(state: State):
-    outputs = []
-    for tool_call in state["messages"][-1].tool_calls:
-        tool_result = tools_by_name[tool_call["name"]].invoke(tool_call["args"])
-        outputs.append(
-            ToolMessage(
-                content=json.dumps(tool_result),
-                name=tool_call["name"],
-                tool_call_id=tool_call["id"],
-            )
-        )
-    return {"messages": outputs}
-
-
-async def agent(state: State):
-    llm = conversation_prompt | model
-    response = await llm.ainvoke(state)
-    return {"messages": response}

src/agents/lesson_practice/prompt.py

@@ -1,94 +0,0 @@
-from langchain_core.prompts import ChatPromptTemplate
-from src.config.llm import model
-
-conversation_prompt = ChatPromptTemplate.from_messages(
-    [
-        (
-            "system",
-            """# English Practice Agent - Adaptive & Personal
-
-## Context Data
-```
-UNIT: {unit}
-VOCABULARY: {vocabulary} 
-KEY STRUCTURES: {key_structures}
-PRACTICE QUESTIONS: {practice_questions}
-STUDENT LEVEL: {student_level}
-```
-
-## 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

src/agents/lesson_practice/tools.py

@@ -1,16 +0,0 @@
-from langchain_core.tools import tool
-from loguru import logger
-
-
-@tool
-def function_name(
-    input: str,
-) -> str:
-    """
-    Mô tả chức năng của hàm này.
-    """
-    logger.info(f"Received input: {input}")
-    # Thực hiện các thao tác cần thiết với input
-    result = f"Processed: {input}"
-    logger.info(f"Returning result: {result}")
-    return result

src/agents/role_play/func.py

@@ -4,6 +4,7 @@ from langgraph.prebuilt import create_react_agent
 from langgraph_swarm import create_handoff_tool
 from langchain_core.messages import RemoveMessage
 from .prompt import roleplay_prompt, guiding_prompt
+from .tools import create_end_conversation_tool
 from typing_extensions import TypedDict, Annotated
 from langchain_core.messages import AnyMessage
 from langgraph.graph import add_messages
@@ -35,6 +36,7 @@ def trim_history(state: State):
 
 async def call_roleplay(state: State):
     logger.info("Calling roleplay agent...")
+
     roleplay_agent = create_react_agent(
         model,
         [
@@ -42,6 +44,7 @@ async def call_roleplay(state: State):
                 agent_name="Guiding Agent",
                 description="Hand off to Guiding Agent when user shows signs of needing help, guidance, or struggles with communication",
             ),
+            create_end_conversation_tool(),
         ],
         prompt=roleplay_prompt.format(
             scenario_title=state["scenario_title"],
@@ -59,6 +62,7 @@ async def call_roleplay(state: State):
 
 async def call_guiding_agent(state: State):
     logger.info("Calling guiding agent...")
+
     guiding_agent = create_react_agent(
         model,
         [
@@ -66,6 +70,7 @@ async def call_guiding_agent(state: State):
                 agent_name="Roleplay Agent",
                 description="Hand off back to Roleplay Agent when user is ready for scenario practice and shows improved confidence",
             ),
+            create_end_conversation_tool(),
         ],
         prompt=guiding_prompt.format(
             scenario_title=state["scenario_title"],
@@ -77,6 +82,7 @@ async def call_guiding_agent(state: State):
         name="Guiding Agent",
     )
     response = await guiding_agent.ainvoke({"messages": state["messages"]})
+
     return {"messages": response["messages"]}
 
 

src/agents/role_play/prompt.py

@@ -94,6 +94,22 @@ Stay true to {your_role}:
 - User asks questions or shares opinions
 - Natural conversation flow develops
 
+## CONVERSATION TERMINATION
+End the conversation naturally when:
+- The user says goodbye, thanks, or indicates they're done (e.g., "Thanks, that's all", "Goodbye", "See you later")
+- The scenario's objectives have been fully explored and the user shows satisfaction
+- The user explicitly states they want to end the conversation
+- After a natural conclusion to the scenario's storyline
+
+When ending the conversation:
+1. Acknowledge what was discussed
+2. Provide a natural closing statement
+3. Thank the user for the conversation
+
+You have access to a special tool to end conversations naturally:
+- Use the "end_conversation" tool when the conversation has reached its natural conclusion
+- Provide a reason for ending the conversation (e.g., "User said goodbye", "Scenario completed")
+
 Remember: You're a real person in your role who's patient with English learners. **Stay true to {your_role} personality and speaking style.** **Keep responses under 15 words typically.** **Use markdown formatting for readability - no icons.** Let them explore topics through questions rather than long explanations.
 """
 
@@ -260,6 +276,23 @@ Brief Vietnamese + English bridge back to roleplay with confidence.
 ### When User Needs Structure:
 Offer practice options in Vietnamese (under 25 words) + "What would you like to practice?"
 
+## CONVERSATION TERMINATION
+End the conversation naturally when:
+- The user says goodbye, thanks, or indicates they're done (e.g., "Thanks, that's all", "Goodbye", "See you later")
+- The learning objectives have been met and the user shows satisfaction
+- The user explicitly states they want to end the conversation
+- After successfully completing a practice activity and the user shows confidence
+
+When ending the conversation:
+1. Acknowledge their progress and efforts
+2. Provide a natural closing statement
+3. Thank the user for the interaction
+4. Encourage them to practice more English
+
+You have access to a special tool to end conversations naturally:
+- Use the "end_conversation" tool when the conversation has reached its natural conclusion
+- Provide a reason for ending the conversation (e.g., "User completed practice", "User said goodbye")
+
 Remember: **I'm WISE, your friendly language safety net!** **NEVER exceed 40 words in any response.** Keep it brief, encouraging, always end with open questions. **Use Vietnamese when they need it.** **Use concise markdown formatting - no icons.** Quick help + confidence building + back to practice!
 
-"""
+"""

src/agents/role_play/tools.py

@@ -1,7 +1,59 @@
 from langchain_core.tools import tool
+from langchain_core.messages import ToolMessage
+from langgraph.types import Command
+from typing import Annotated, Any
+from langgraph_swarm.handoff import _get_field, InjectedState
 from loguru import logger
 
 
+def create_end_conversation_tool(
+    name: str = "end_conversation",
+    description: str = "End the conversation naturally when the discussion has reached its conclusion or the user indicates they want to stop",
+) -> callable:
+    """Create a tool that can end the conversation.
+
+    Args:
+        name: Name of the tool to use for ending the conversation.
+        description: Description for the end conversation tool.
+
+    Returns:
+        A tool that when called will end the conversation.
+    """
+
+    @tool(name, description=description)
+    def end_conversation(
+        reason: str,
+        # Annotation is typed as Any instead of StateLike. StateLike
+        # trigger validation issues from Pydantic / langchain_core interaction.
+        # https://github.com/langchain-ai/langchain/issues/32067
+        state: Annotated[Any, InjectedState],
+        tool_call_id: str,
+    ) -> Command:
+        """End the conversation with the given reason.
+
+        Args:
+            reason: The reason for ending the conversation
+        """
+        logger.info(f"Conversation ended. Reason: {reason}")
+
+        tool_message = ToolMessage(
+            content=f"Conversation ended: {reason}",
+            name=name,
+            tool_call_id=tool_call_id,
+        )
+
+        # Return a Command that goes to END node
+        return Command(
+            # goto="END",
+            graph=Command.PARENT,
+            update={
+                "messages": [*_get_field(state, "messages"), tool_message],
+            },
+        )
+
+    return end_conversation
+
+
 @tool
 def function_name(
     input: str,

src/apis/create_app.py

@@ -3,11 +3,13 @@ from fastapi.middleware.cors import CORSMiddleware
 from src.apis.routes.user_route import router as router_user
 from src.apis.routes.chat_route import router as router_chat
 from src.apis.routes.lesson_route import router as router_lesson
+from src.apis.routes.evaluation_route import router as router_evaluation
 
 api_router = APIRouter(prefix="/api")
 api_router.include_router(router_user)
 api_router.include_router(router_chat)
 api_router.include_router(router_lesson)
+api_router.include_router(router_evaluation)
 
 
 def create_app():
@@ -21,4 +23,4 @@ def create_app():
         allow_headers=["*"],
     )
 
-    return app
+    return app

src/apis/routes/chat_route.py

@@ -149,7 +149,7 @@ async def roleplay_stream(
 ):
     """Send a message (text or audio) to the roleplay agent with streaming response"""
     logger.info(f"Received streaming roleplay request: {session_id}")
-    
+
     # Validate that at least one input is provided
     if not text_message and not audio_file:
         raise HTTPException(
@@ -217,6 +217,7 @@ async def roleplay_stream(
     async def generate_stream():
         """Generator function for streaming responses"""
         accumulated_content = ""
+        conversation_ended = False
         try:
             input_graph = {
                 "messages": [message],
@@ -230,7 +231,7 @@ async def roleplay_stream(
 
             async for event in role_play_agent().astream(
                 input=input_graph,
-                stream_mode=["messages"],
+                stream_mode=["messages", "values"],
                 config=config,
                 subgraphs=True,
             ):
@@ -239,56 +240,79 @@ async def roleplay_stream(
                     # message_chunk is a tuple, get the first element which is the actual AIMessageChunk
                     if isinstance(message_chunk, tuple) and len(message_chunk) > 0:
                         actual_message = message_chunk[0]
-                        content = getattr(actual_message, 'content', '')
+                        content = getattr(actual_message, "content", "")
                     else:
                         actual_message = message_chunk
-                        content = getattr(message_chunk, 'content', '')
-                        
-                    if content:
+                        content = getattr(message_chunk, "content", "")
+
+                    # Check if this is a tool call message and if it's an end conversation tool call
+                    if (
+                        hasattr(actual_message, "tool_calls")
+                        and actual_message.tool_calls
+                    ):
+                        # Check if any tool call is for ending the conversation
+                        for tool_call in actual_message.tool_calls:
+                            if (
+                                isinstance(tool_call, dict)
+                                and tool_call.get("name") == "end_conversation"
+                            ):
+                                # Send a special termination message to the client
+                                termination_data = {
+                                    "type": "termination",
+                                    "content": "Conversation ended",
+                                    "reason": tool_call.get("args", {}).get("reason", "Unknown reason")
+                                }
+                                yield f"data: {json.dumps(termination_data)}\n\n"
+                                conversation_ended = True
+                                break
+
+                    if content and not conversation_ended:
                         # Accumulate content for TTS
                         accumulated_content += content
-                        
+
                         # Create SSE-formatted response
                         response_data = {
                             "type": "message_chunk",
                             "content": content,
                             "metadata": {
-                                "agent": getattr(actual_message, 'name', 'unknown'),
-                                "id": getattr(actual_message, 'id', ''),
-                                "usage_metadata": getattr(actual_message, 'usage_metadata', {})
-                            }
+                                "agent": getattr(actual_message, "name", "unknown"),
+                                "id": getattr(actual_message, "id", ""),
+                                "usage_metadata": getattr(
+                                    actual_message, "usage_metadata", {}
+                                ),
+                            },
                         }
                         yield f"data: {json.dumps(response_data)}\n\n"
-                        
+
                         # Small delay to prevent overwhelming the client
                         await asyncio.sleep(0.01)
-            
-            # Generate TTS audio if requested
-            audio_data = None
-            if audio and accumulated_content.strip():
-                try:
-                    logger.info(f"Generating TTS for accumulated content: {len(accumulated_content)} chars")
-                    audio_result = await tts_service.text_to_speech(accumulated_content)
-                    if audio_result:
-                        audio_data = {
-                            "audio_data": audio_result["audio_data"],
-                            "mime_type": audio_result["mime_type"],
-                            "format": audio_result["format"]
-                        }
-                        logger.info("TTS audio generated successfully")
-                    else:
-                        logger.warning("TTS generation failed")
-                except Exception as tts_error:
-                    logger.error(f"TTS generation error: {str(tts_error)}")
-            
-            # Send completion signal with optional audio
-            completion_data = {
-                "type": "completion", 
-                "content": "",
-                "audio": audio_data
-            }
-            yield f"data: {json.dumps(completion_data)}\n\n"
-            
+
+            # Only send completion signal if conversation wasn't ended by tool call
+            if not conversation_ended:
+                # Generate TTS audio if requested
+                audio_data = None
+                if audio and accumulated_content.strip():
+                    try:
+                        logger.info(
+                            f"Generating TTS for accumulated content: {len(accumulated_content)} chars"
+                        )
+                        audio_result = await tts_service.text_to_speech(accumulated_content)
+                        if audio_result:
+                            audio_data = {
+                                "audio_data": audio_result["audio_data"],
+                                "mime_type": audio_result["mime_type"],
+                                "format": audio_result["format"],
+                            }
+                            logger.info("TTS audio generated successfully")
+                        else:
+                            logger.warning("TTS generation failed")
+                    except Exception as tts_error:
+                        logger.error(f"TTS generation error: {str(tts_error)}")
+
+                # Send completion signal with optional audio
+                completion_data = {"type": "completion", "content": "", "audio": audio_data}
+                yield f"data: {json.dumps(completion_data)}\n\n"
+
         except Exception as e:
             logger.error(f"Error in streaming roleplay: {str(e)}")
             error_data = {"type": "error", "content": str(e)}

src/apis/routes/evaluation_route.py

@@ -0,0 +1,48 @@
+from fastapi import APIRouter, status, HTTPException
+from pydantic import BaseModel
+from src.agents.evaluation.agent import evaluate_conversation
+from src.utils.logger import logger
+from typing import Optional
+
+router = APIRouter(prefix="/evaluation", tags=["Evaluation"])
+
+
+class EvaluationRequest(BaseModel):
+    session_id: str
+    learner_level: str = "beginner"
+    scenario_title: Optional[str] = ""
+    scenario_description: Optional[str] = ""
+    key_vocabulary: Optional[str] = ""
+
+
+class EvaluationResponse(BaseModel):
+    score: int
+    feedback: str
+    strengths: list
+    improvements: list
+    suggestions: list
+    next_steps: list
+
+
+@router.post("/conversation", response_model=EvaluationResponse, status_code=status.HTTP_200_OK)
+async def evaluate_conversation_endpoint(request: EvaluationRequest):
+    """Evaluate a conversation and provide feedback"""
+    logger.info(f"Received evaluation request for session: {request.session_id}")
+    
+    try:
+        result = await evaluate_conversation(
+            session_id=request.session_id,
+            learner_level=request.learner_level,
+            scenario_title=request.scenario_title or "",
+            scenario_description=request.scenario_description or "",
+            key_vocabulary=request.key_vocabulary or ""
+        )
+        
+        return EvaluationResponse(**result)
+        
+    except Exception as e:
+        logger.error(f"Error in conversation evaluation: {str(e)}")
+        raise HTTPException(
+            status_code=500, 
+            detail=f"Failed to evaluate conversation: {str(e)}"
+        )

src/apis/routes/lesson_route.py

@@ -13,7 +13,6 @@ from src.utils.logger import logger
 from src.services.tts_service import tts_service
 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
@@ -42,15 +41,17 @@ 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:
@@ -58,9 +59,11 @@ 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)}")
@@ -71,22 +74,19 @@ 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",
         )
 
 
@@ -94,25 +94,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
@@ -120,7 +120,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",
         )
 
 
@@ -128,31 +128,27 @@ 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",
         )
 
 
@@ -161,110 +157,7 @@ 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"
-    ),
-    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 agent"""
-
-    # 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_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: {ai_response}")
-
-        return JSONResponse(content={"response": ai_response})
-
-    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"
-    ),
+    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"),
 ):
@@ -346,7 +239,7 @@ async def chat_v2(
             },
             {"configurable": {"thread_id": session_id}},
         )
-        
+
         # Extract AI response content
         ai_response = response["messages"][-1].content
         logger.info(f"AI response (v2): {ai_response}")
@@ -358,21 +251,19 @@ async def chat_v2(
         raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
 
 
-@router.post("/chat_v2/stream", status_code=status.HTTP_200_OK)
-async def chat_v2_stream(
+@router.post("/chat/stream", status_code=status.HTTP_200_OK)
+async def chat_stream(
     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"),
     audio: bool = Form(False, description="Whether to return TTS audio response"),
 ):
     """Send a message (text or audio) to the lesson practice v2 agent with streaming response"""
     logger.info(f"Received streaming lesson practice v2 request: {session_id}")
-    
+
     # Validate that at least one input is provided
     if not text_message and not audio_file:
         raise HTTPException(
@@ -462,56 +353,56 @@ async def chat_v2_stream(
                     # message_chunk is a tuple, get the first element which is the actual AIMessageChunk
                     if isinstance(message_chunk, tuple) and len(message_chunk) > 0:
                         actual_message = message_chunk[0]
-                        content = getattr(actual_message, 'content', '')
+                        content = getattr(actual_message, "content", "")
                     else:
                         actual_message = message_chunk
-                        content = getattr(message_chunk, 'content', '')
-                        
+                        content = getattr(message_chunk, "content", "")
+
                     if content:
                         # Accumulate content for TTS
                         accumulated_content += content
-                        
+
                         # Create SSE-formatted response
                         response_data = {
                             "type": "message_chunk",
                             "content": content,
                             "metadata": {
-                                "agent": getattr(actual_message, 'name', 'unknown'),
-                                "id": getattr(actual_message, 'id', ''),
-                                "usage_metadata": getattr(actual_message, 'usage_metadata', {})
-                            }
+                                "agent": getattr(actual_message, "name", "unknown"),
+                                "id": getattr(actual_message, "id", ""),
+                                "usage_metadata": getattr(
+                                    actual_message, "usage_metadata", {}
+                                ),
+                            },
                         }
                         yield f"data: {json.dumps(response_data)}\n\n"
-                        
+
                         # Small delay to prevent overwhelming the client
                         await asyncio.sleep(0.01)
-            
+
             # Generate TTS audio if requested
             audio_data = None
             if audio and accumulated_content.strip():
                 try:
-                    logger.info(f"Generating TTS for lesson v2 content: {len(accumulated_content)} chars")
+                    logger.info(
+                        f"Generating TTS for lesson v2 content: {len(accumulated_content)} chars"
+                    )
                     audio_result = await tts_service.text_to_speech(accumulated_content)
                     if audio_result:
                         audio_data = {
                             "audio_data": audio_result["audio_data"],
                             "mime_type": audio_result["mime_type"],
-                            "format": audio_result["format"]
+                            "format": audio_result["format"],
                         }
                         logger.info("Lesson v2 TTS audio generated successfully")
                     else:
                         logger.warning("Lesson v2 TTS generation failed")
                 except Exception as tts_error:
                     logger.error(f"Lesson v2 TTS generation error: {str(tts_error)}")
-            
+
             # Send completion signal with optional audio
-            completion_data = {
-                "type": "completion", 
-                "content": "",
-                "audio": audio_data
-            }
+            completion_data = {"type": "completion", "content": "", "audio": audio_data}
             yield f"data: {json.dumps(completion_data)}\n\n"
-            
+
         except Exception as e:
             logger.error(f"Error in streaming lesson practice v2: {str(e)}")
             error_data = {"type": "error", "content": str(e)}