Update app/main.py

app/main.py

@@ -1,17 +1,16 @@
+
 import json
 import os
 import re
-import tempfile
 from statistics import mean
 from typing import Any, Dict, List, Optional
 
 import requests
 from fastapi import FastAPI, File, Form, UploadFile
 from fastapi.middleware.cors import CORSMiddleware
-from faster_whisper import WhisperModel
 from pydantic import BaseModel
 
-app = FastAPI(title="Japanese AI Interview API", version="2.0.0")
+app = FastAPI(title="Japanese AI Interview API", version="2.1.0")
 
 app.add_middleware(
     CORSMiddleware,
@@ -21,13 +20,15 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-ASR_MODEL_NAME = os.getenv("ASR_MODEL", "small")
 HF_TOKEN = os.getenv("HF_TOKEN", "").strip()
+ASR_MODEL_NAME = os.getenv("ASR_MODEL", "openai/whisper-large-v3")
 CHAT_MODEL = os.getenv("CHAT_MODEL", "Qwen/Qwen2.5-7B-Instruct-1M")
 MAX_DYNAMIC_QUESTIONS = int(os.getenv("MAX_DYNAMIC_QUESTIONS", "10"))
 MIN_DYNAMIC_QUESTIONS = int(os.getenv("MIN_DYNAMIC_QUESTIONS", "3"))
 HF_ROUTER_URL = os.getenv("HF_ROUTER_URL", "https://router.huggingface.co/v1/chat/completions")
+HF_INFERENCE_BASE = os.getenv("HF_INFERENCE_BASE", "https://router.huggingface.co/hf-inference/models")
 LLM_TIMEOUT_SECONDS = int(os.getenv("LLM_TIMEOUT_SECONDS", "90"))
+ASR_TIMEOUT_SECONDS = int(os.getenv("ASR_TIMEOUT_SECONDS", "180"))
 
 OPENING_QUESTION = "こんにちは。本日は面接に来ていただきありがとうございます。まず、お名前を教えてください。"
 
@@ -42,9 +43,6 @@ FALLBACK_TOPIC_QUESTIONS = [
     ("experience", "これまでの仕事や勉強の経験について少し話してください。"),
 ]
 
-_model: Optional[WhisperModel] = None
-
-
 class StartRequest(BaseModel):
     session_uuid: str
     interview_type: str = "jp_dynamic"
@@ -56,7 +54,7 @@ def root() -> Dict[str, Any]:
     return {
         "ok": True,
         "service": "jp-interview",
-        "version": "2.0.0",
+        "version": "2.1.0",
         "routes": ["/health", "/start", "/answer"],
     }
 
@@ -66,18 +64,21 @@ def health() -> Dict[str, Any]:
     return {
         "ok": True,
         "service": "jp-interview",
-        "version": "2.0.0",
+        "version": "2.1.0",
         "asr_model": ASR_MODEL_NAME,
         "llm_enabled": bool(HF_TOKEN),
         "chat_model": CHAT_MODEL,
         "auto_question_mode": True,
         "min_dynamic_questions": MIN_DYNAMIC_QUESTIONS,
         "max_dynamic_questions": MAX_DYNAMIC_QUESTIONS,
+        "uses_native_faster_whisper": False,
     }
 
 
 @app.post("/start")
 def start_interview(payload: StartRequest) -> Dict[str, Any]:
+    min_q = MIN_DYNAMIC_QUESTIONS
+    max_q = MAX_DYNAMIC_QUESTIONS
     memory = {
         "candidate_name": None,
         "country_name": None,
@@ -85,25 +86,25 @@ def start_interview(payload: StartRequest) -> Dict[str, Any]:
         "reason_for_japan": None,
         "occupation": None,
         "japanese_level": None,
-        "ready_confirmed": None,
         "answers_so_far": [],
         "asked_topics": ["name"],
         "interview_type": payload.interview_type,
         "auto_question_mode": True,
-        "min_questions": MIN_DYNAMIC_QUESTIONS,
-        "max_questions": MAX_DYNAMIC_QUESTIONS,
+        "min_questions": min_q,
+        "max_questions": max_q,
+        "low_score_count": 0,
+        "no_sound_count": 0,
     }
     return {
         "ok": True,
         "session_uuid": payload.session_uuid,
         "question_no": 1,
-        "question_count": MAX_DYNAMIC_QUESTIONS,
+        "question_count_mode": "auto",
         "question_jp": OPENING_QUESTION,
-        "speech_text_jp": OPENING_QUESTION,
-        "plan_text_jp": "質問数はあなたのパフォーマンスによって自動で決まります。",
         "memory": memory,
         "is_finished": False,
         "speak_now": True,
+        "speech_text_jp": OPENING_QUESTION,
     }
 
 
@@ -111,30 +112,49 @@ def start_interview(payload: StartRequest) -> Dict[str, Any]:
 async def answer_interview(
     session_uuid: str = Form(...),
     question_no: int = Form(...),
-    question_count: int = Form(0),
+    question_count: Optional[int] = Form(None),
     question_jp: str = Form(...),
     memory_json: str = Form("{}"),
     audio: UploadFile = File(...),
 ) -> Dict[str, Any]:
     memory = safe_json_loads(memory_json)
-    question_count = max(
-        int(memory.get("min_questions", MIN_DYNAMIC_QUESTIONS)),
-        min(int(memory.get("max_questions", MAX_DYNAMIC_QUESTIONS)), int(memory.get("max_questions", MAX_DYNAMIC_QUESTIONS)))
-    )
     memory.setdefault("answers_so_far", [])
     memory.setdefault("asked_topics", [])
+    memory.setdefault("low_score_count", 0)
+    memory.setdefault("no_sound_count", 0)
 
     transcript = await transcribe_upload(audio)
+
     if not transcript.strip():
-        repeat_prompt = build_repeat_prompt(memory, question_jp)
+        memory["no_sound_count"] = int(memory.get("no_sound_count", 0)) + 1
+        candidate_name = memory.get("candidate_name")
+        repeat_prompt = "声が小さいです。もう少し大きい声で、もう一度お願いします。"
+        if candidate_name:
+            repeat_prompt = f"{candidate_name}さん、声が小さいです。もう少し大きい声で、もう一度お願いします。"
+
+        if memory["no_sound_count"] >= 2 and len(memory.get("answers_so_far", [])) >= MIN_DYNAMIC_QUESTIONS:
+            result = build_fallback_final_result(memory, memory.get("answers_so_far", []))
+            result["closing_message_jp"] = "音声が聞こえないため、面接を終了します。ありがとうございました。"
+            return {
+                "ok": True,
+                "is_finished": True,
+                "session_uuid": session_uuid,
+                "question_no": question_no,
+                "transcript_jp": "",
+                "answer_score": 0,
+                "feedback_jp": repeat_prompt,
+                "speech_text_jp": repeat_prompt,
+                "memory": memory,
+                "llm_used": False,
+                "result": result,
+            }
+
         return {
             "ok": True,
             "is_finished": False,
             "needs_repeat": True,
             "session_uuid": session_uuid,
             "question_no": question_no,
-            "question_count": int(merged_memory.get("max_questions", question_count)),
-            "question_jp": question_jp,
             "transcript_jp": "",
             "answer_score": 0,
             "feedback_jp": repeat_prompt,
@@ -146,6 +166,8 @@ async def answer_interview(
             "llm_used": False,
         }
 
+    memory["no_sound_count"] = 0
+
     answer_turn = {
         "question_no": question_no,
         "question_jp": question_jp,
@@ -155,12 +177,10 @@ async def answer_interview(
     history.append(answer_turn)
 
     llm_used = False
-    evaluation: Dict[str, Any]
     if HF_TOKEN:
         try:
             evaluation = run_llm_turn(
                 question_no=question_no,
-                question_count=question_count,
                 current_question=question_jp,
                 transcript=transcript,
                 memory=memory,
@@ -168,25 +188,9 @@ async def answer_interview(
             )
             llm_used = True
         except Exception as exc:
-            evaluation = fallback_turn_evaluation(
-                question_no=question_no,
-                question_count=question_count,
-                current_question=question_jp,
-                transcript=transcript,
-                memory=memory,
-                history=history,
-                error=str(exc),
-            )
+            evaluation = fallback_turn_evaluation(question_no, transcript, memory, history, error=str(exc))
     else:
-        evaluation = fallback_turn_evaluation(
-            question_no=question_no,
-            question_count=question_count,
-            current_question=question_jp,
-            transcript=transcript,
-            memory=memory,
-            history=history,
-            error="HF_TOKEN is not set.",
-        )
+        evaluation = fallback_turn_evaluation(question_no, transcript, memory, history, error="HF_TOKEN is not set.")
 
     profile_update = evaluation.get("profile_update", {})
     merged_memory = merge_memory(memory, profile_update)
@@ -197,29 +201,37 @@ async def answer_interview(
     feedback_jp = clean_text(evaluation.get("feedback_jp")) or default_feedback(answer_score)
     history[-1]["answer_score"] = answer_score
     history[-1]["feedback_jp"] = feedback_jp
-    history[-1]["question_topic"] = evaluation.get("question_topic")
-
-    should_finish = should_finish_dynamically(merged_memory, answer_score, question_no, bool(evaluation.get("continue_interview") is False))
-
-    if should_finish:
-        final_result = run_final_evaluation_if_possible(
-            merged_memory=merged_memory,
-            history=history,
-            llm_used=llm_used,
-        )
-        if merged_memory.get("candidate_name"):
-            final_result["closing_message_jp"] = f'{merged_memory.get("candidate_name")}さん、本日の面接練習はここまでです。ご参加ありがとうございました。'
-        else:
-            final_result["closing_message_jp"] = "本日の面接練習はここまでです。ご参加ありがとうございました。"
+
+    if answer_score <= 3:
+        merged_memory["low_score_count"] = int(memory.get("low_score_count", 0)) + 1
+    else:
+        merged_memory["low_score_count"] = 0
+
+    total_answers = len(history)
+    auto_finish = False
+    if total_answers >= MIN_DYNAMIC_QUESTIONS:
+        avg_score = mean([int(x.get("answer_score", 0)) for x in history])
+        if merged_memory["low_score_count"] >= 2 or avg_score < 3.5:
+            auto_finish = True
+        elif total_answers >= MAX_DYNAMIC_QUESTIONS:
+            auto_finish = True
+        elif avg_score >= 7 and total_answers < MAX_DYNAMIC_QUESTIONS:
+            auto_finish = False
+        elif total_answers >= 6 and avg_score < 6:
+            auto_finish = True
+
+    if auto_finish:
+        final_result = run_final_evaluation_if_possible(merged_memory, history, llm_used=llm_used)
+        final_result["closing_message_jp"] = "本日の面接練習はここまでです。ご参加ありがとうございました。"
         return {
             "ok": True,
             "is_finished": True,
             "session_uuid": session_uuid,
             "question_no": question_no,
-            "question_count": int(merged_memory.get("max_questions", question_count)),
             "transcript_jp": transcript,
             "answer_score": answer_score,
             "feedback_jp": feedback_jp,
+            "speech_text_jp": final_result["closing_message_jp"],
             "memory": merged_memory,
             "llm_used": llm_used,
             "result": final_result,
@@ -230,18 +242,20 @@ async def answer_interview(
     if not next_question_jp:
         next_question_jp = choose_fallback_next_question(merged_memory, history)
 
-    speech_text_jp = build_speech_text(merged_memory, feedback_jp, next_question_jp)
+    candidate_name = merged_memory.get("candidate_name")
+    speech_text = next_question_jp
+    if candidate_name and question_no == 1:
+        speech_text = f"{candidate_name}さん、ありがとうございます。面接の準備はできていますか。"
 
     return {
         "ok": True,
         "is_finished": False,
         "session_uuid": session_uuid,
         "question_no": question_no,
-        "question_count": int(merged_memory.get("max_questions", question_count)),
         "transcript_jp": transcript,
         "answer_score": answer_score,
         "feedback_jp": feedback_jp,
-        "speech_text_jp": speech_text_jp,
+        "speech_text_jp": speech_text,
         "memory": merged_memory,
         "llm_used": llm_used,
         "next_question_no": next_question_no,
@@ -250,30 +264,42 @@ async def answer_interview(
     }
 
 
-def get_model() -> WhisperModel:
-    global _model
-    if _model is None:
-        _model = WhisperModel(ASR_MODEL_NAME, device="cpu", compute_type="int8")
-    return _model
+async def transcribe_upload(audio: UploadFile) -> str:
+    if not HF_TOKEN:
+        return ""
+    filename = audio.filename or "upload.webm"
+    content = await audio.read()
+    if not content:
+        return ""
+
+    url = f"{HF_INFERENCE_BASE}/{ASR_MODEL_NAME}"
+    headers = {
+        "Authorization": f"Bearer {HF_TOKEN}",
+        "Content-Type": guess_mime_type(filename),
+    }
+    response = requests.post(url, headers=headers, data=content, timeout=ASR_TIMEOUT_SECONDS)
+    response.raise_for_status()
+    data = response.json()
 
+    text = ""
+    if isinstance(data, dict):
+        text = data.get("text") or data.get("generated_text") or ""
+    elif isinstance(data, list) and data and isinstance(data[0], dict):
+        text = data[0].get("text", "")
+    return normalize_text(text)
 
-async def transcribe_upload(audio: UploadFile) -> str:
-    suffix = os.path.splitext(audio.filename or "upload.webm")[1] or ".webm"
-    with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tmp:
-        content = await audio.read()
-        tmp.write(content)
-        temp_path = tmp.name
 
-    try:
-        model = get_model()
-        segments, _info = model.transcribe(temp_path, language="ja", vad_filter=True)
-        text = " ".join(seg.text.strip() for seg in segments).strip()
-        return normalize_text(text)
-    finally:
-        try:
-            os.remove(temp_path)
-        except OSError:
-            pass
+def guess_mime_type(filename: str) -> str:
+    name = (filename or "").lower()
+    if name.endswith(".wav"):
+        return "audio/wav"
+    if name.endswith(".mp3"):
+        return "audio/mpeg"
+    if name.endswith(".m4a"):
+        return "audio/mp4"
+    if name.endswith(".ogg"):
+        return "audio/ogg"
+    return "audio/webm"
 
 
 def normalize_text(text: str) -> str:
@@ -342,7 +368,7 @@ def safe_json_loads(value: str) -> Dict[str, Any]:
         return {}
 
 
-def maybe_extract_basic_profile(memory: Dict[str, Any], transcript: str, question_no: int, current_question: str = "") -> Dict[str, Any]:
+def maybe_extract_basic_profile(memory: Dict[str, Any], transcript: str, question_no: int) -> Dict[str, Any]:
     update: Dict[str, Any] = {}
     text = transcript.strip()
 
@@ -370,12 +396,6 @@ def maybe_extract_basic_profile(memory: Dict[str, Any], transcript: str, questio
     if not memory.get("japanese_level") and any(x in text for x in ["日本語", "勉強", "年", "ヶ月", "少し"]):
         update["japanese_level"] = text[:80]
 
-    if "準備はできていますか" in current_question:
-        if any(x in text for x in ["はい", "大丈夫", "準備でき", "できます"]):
-            update["ready_confirmed"] = True
-        elif any(x in text for x in ["いいえ", "まだ", "少し", "できていません"]):
-            update["ready_confirmed"] = False
-
     return update
 
 
@@ -402,60 +422,31 @@ def extract_age(text: str) -> Optional[int]:
     match = re.search(r"(\d{1,2})", text)
     if match:
         return int(match.group(1))
-    kanji_map = {"一":1,"二":2,"三":3,"四":4,"五":5,"六":6,"七":7,"八":8,"九":9}
-    # very simple fallback like 二十五
-    km = re.search(r"([二三四五六七八九]?十?[一二三四五六七八九]?)歳", text)
-    if km:
-        s = km.group(1)
-        if s == "十":
-            return 10
-        total = 0
-        if "十" in s:
-            parts = s.split("十")
-            total += (kanji_map.get(parts[0], 1) if parts[0] else 1) * 10
-            if len(parts) > 1 and parts[1]:
-                total += kanji_map.get(parts[1], 0)
-            return total or None
-        return kanji_map.get(s)
     return None
 
 
 def choose_fallback_next_question(memory: Dict[str, Any], history: List[Dict[str, Any]]) -> str:
+    for topic, question in FALLBACK_TOPIC_QUESTIONS:
+        if topic == "name" and not memory.get("candidate_name"):
+            return question
+        if topic == "country" and not memory.get("country_name"):
+            return question
+        if topic == "age" and not memory.get("age"):
+            return question
+        if topic == "reason_for_japan" and not memory.get("reason_for_japan"):
+            return question
+        if topic == "occupation" and not memory.get("occupation"):
+            return question
+        if topic == "japanese_level" and not memory.get("japanese_level"):
+            return question
+        if topic in ["strength", "experience"] and len(history) < 8:
+            return question
     name = memory.get("candidate_name") or "あなた"
-
-    if not memory.get("candidate_name"):
-        return "お名前を教えてください。"
-
-    if memory.get("ready_confirmed") is None:
-        return f"{name}さん、ありがとうございます。面接の準備はできていますか。"
-
-    if not memory.get("country_name"):
-        return f"{name}さん、ありがとうございます。どこの国から来ましたか。"
-    if not memory.get("age"):
-        return f"{name}さん、年齢は何歳ですか。"
-    if not memory.get("reason_for_japan"):
-        return f"{name}さん、日本へ行きたい理由は何ですか。"
-    if not memory.get("occupation"):
-        return f"{name}さん、今は仕事をしていますか。それとも勉強していますか。"
-    if not memory.get("japanese_level"):
-        return f"{name}さん、日本語はどのくらい勉強しましたか。"
-
-    if len(history) < 8:
-        return f"{name}さん、これまでの仕事や勉強の経験について少し話してください。"
-
     return f"{name}さん、最後に自分の強みを一つ話してください。"
 
 
-def fallback_turn_evaluation(
-    question_no: int,
-    question_count: int,
-    current_question: str,
-    transcript: str,
-    memory: Dict[str, Any],
-    history: List[Dict[str, Any]],
-    error: str,
-) -> Dict[str, Any]:
-    profile_update = maybe_extract_basic_profile(memory, transcript, question_no, current_question)
+def fallback_turn_evaluation(question_no: int, transcript: str, memory: Dict[str, Any], history: List[Dict[str, Any]], error: str) -> Dict[str, Any]:
+    profile_update = maybe_extract_basic_profile(memory, transcript, question_no)
     asked_topics = []
     for key in profile_update.keys():
         if key == "candidate_name":
@@ -479,14 +470,7 @@ def fallback_turn_evaluation(
     }
 
 
-def run_llm_turn(
-    question_no: int,
-    question_count: int,
-    current_question: str,
-    transcript: str,
-    memory: Dict[str, Any],
-    history: List[Dict[str, Any]],
-) -> Dict[str, Any]:
+def run_llm_turn(question_no: int, current_question: str, transcript: str, memory: Dict[str, Any], history: List[Dict[str, Any]]) -> Dict[str, Any]:
     system_prompt = (
         "You are a Japanese mock interview examiner for learners. "
         "Always think about the candidate's previous answers and ask ONE natural next interview question in Japanese. "
@@ -495,10 +479,8 @@ def run_llm_turn(
         "Use Japanese for next_question_jp and feedback_jp. "
         "Return ONLY valid JSON."
     )
-
     payload = {
         "question_no": question_no,
-        "question_count": int(merged_memory.get("max_questions", question_count)),
         "current_question_jp": current_question,
         "user_answer_jp": transcript,
         "profile_memory": {
@@ -510,15 +492,7 @@ def run_llm_turn(
             "japanese_level": memory.get("japanese_level"),
         },
         "history": history,
-        "required_topics": [
-            "name",
-            "country",
-            "age",
-            "reason_for_japan",
-            "occupation_or_study",
-            "japanese_level",
-            "strength_or_experience",
-        ],
+        "required_topics": ["name","country","reason_for_japan","occupation_or_study","japanese_level","strength_or_experience"],
         "output_schema": {
             "answer_score": "integer 0-10",
             "feedback_jp": "short Japanese feedback",
@@ -530,32 +504,15 @@ def run_llm_turn(
                 "age": "number or null",
                 "reason_for_japan": "string or null",
                 "occupation": "string or null",
-                "japanese_level": "string or null",
+                "japanese_level": "string or null"
             },
             "continue_interview": "boolean",
-            "next_question_jp": "string when continue_interview is true, else empty string",
-        },
-        "rules": [
-            "If the answer is unclear, ask a short clarification question.",
-            "Use the candidate name in the next question if known.",
-            "Do not ask more than one question.",
-            "The interview length is dynamic based on performance.",
-            "Weak performance may end after 3 to 5 questions.",
-            "Good performance may continue longer, up to the internal max.",
-            "Do not mention JSON or scoring in Japanese to the candidate.",
-        ],
+            "next_question_jp": "string"
+        }
     }
-
     raw = call_hf_chat_json(system_prompt=system_prompt, user_payload=payload)
     result = normalize_llm_turn_result(raw)
-
-    result["profile_update"] = merge_memory(
-        maybe_extract_basic_profile(memory, transcript, question_no, current_question),
-        result.get("profile_update", {}),
-    )
-    if question_no >= question_count:
-        result["continue_interview"] = False
-        result["next_question_jp"] = ""
+    result["profile_update"] = merge_memory(maybe_extract_basic_profile(memory, transcript, question_no), result.get("profile_update", {}))
     return result
 
 
@@ -563,11 +520,9 @@ def normalize_llm_turn_result(raw: Dict[str, Any]) -> Dict[str, Any]:
     profile = raw.get("profile_update", {})
     if not isinstance(profile, dict):
         profile = {}
-
     asked_topics = raw.get("asked_topics", [])
     if not isinstance(asked_topics, list):
         asked_topics = []
-
     return {
         "answer_score": clamp_int(raw.get("answer_score", 6), 0, 10),
         "feedback_jp": clean_text(raw.get("feedback_jp")),
@@ -603,7 +558,6 @@ def normalize_optional_int(value: Any) -> Optional[int]:
 def call_hf_chat_json(system_prompt: str, user_payload: Dict[str, Any]) -> Dict[str, Any]:
     if not HF_TOKEN:
         raise RuntimeError("HF_TOKEN is missing.")
-
     body = {
         "model": CHAT_MODEL,
         "messages": [
@@ -614,38 +568,24 @@ def call_hf_chat_json(system_prompt: str, user_payload: Dict[str, Any]) -> Dict[
         "max_tokens": 700,
         "response_format": {"type": "json_object"},
     }
-
     response = requests.post(
         HF_ROUTER_URL,
-        headers={
-            "Authorization": f"Bearer {HF_TOKEN}",
-            "Content-Type": "application/json",
-        },
+        headers={"Authorization": f"Bearer {HF_TOKEN}", "Content-Type": "application/json"},
         json=body,
         timeout=LLM_TIMEOUT_SECONDS,
     )
     response.raise_for_status()
     data = response.json()
-
-    content = (
-        data.get("choices", [{}])[0]
-        .get("message", {})
-        .get("content", "")
-    )
+    content = data.get("choices", [{}])[0].get("message", {}).get("content", "")
     if not content:
         raise RuntimeError("HF router returned an empty completion.")
-
     parsed = json.loads(content)
     if not isinstance(parsed, dict):
         raise RuntimeError("HF router response was not a JSON object.")
     return parsed
 
 
-def run_final_evaluation_if_possible(
-    merged_memory: Dict[str, Any],
-    history: List[Dict[str, Any]],
-    llm_used: bool,
-) -> Dict[str, Any]:
+def run_final_evaluation_if_possible(merged_memory: Dict[str, Any], history: List[Dict[str, Any]], llm_used: bool) -> Dict[str, Any]:
     if llm_used and HF_TOKEN:
         try:
             return run_llm_final_evaluation(merged_memory, history)
@@ -658,8 +598,7 @@ def run_llm_final_evaluation(merged_memory: Dict[str, Any], history: List[Dict[s
     system_prompt = (
         "You are a Japanese interview evaluator. "
         "Review the interview history and return ONLY valid JSON. "
-        "Use short Japanese for summary_jp. "
-        "Strengths, weaknesses, and tips should be simple English bullet phrases to help the app UI."
+        "Use short Japanese for summary_jp."
     )
     payload = {
         "profile_memory": merged_memory,
@@ -667,36 +606,22 @@ def run_llm_final_evaluation(merged_memory: Dict[str, Any], history: List[Dict[s
         "output_schema": {
             "summary_jp": "short Japanese summary",
             "overall_score": "integer 0-100",
-            "scores": {
-                "fluency": "integer 1-10",
-                "grammar": "integer 1-10",
-                "confidence": "integer 1-10",
-                "relevance": "integer 1-10",
-            },
+            "scores": {"fluency":"integer 1-10","grammar":"integer 1-10","confidence":"integer 1-10","relevance":"integer 1-10"},
             "pass_fail": "PASS or FAIL",
-            "strengths": ["array of short strings"],
-            "weaknesses": ["array of short strings"],
-            "tips": ["array of short strings"],
-        },
-        "rules": [
-            "Be fair to beginner learners.",
-            "Do not invent long stories.",
-            "Base the result on the actual history only.",
-        ],
+            "strengths": ["array"],
+            "weaknesses": ["array"],
+            "tips": ["array"]
+        }
     }
     raw = call_hf_chat_json(system_prompt=system_prompt, user_payload=payload)
-
-    summary_jp = clean_text(raw.get("summary_jp")) or "面接が完了しました。"
-    overall_score = clamp_int(raw.get("overall_score", 65), 0, 100)
     raw_scores = raw.get("scores", {}) if isinstance(raw.get("scores"), dict) else {}
-
     return {
         "candidate_name": merged_memory.get("candidate_name"),
         "country_name": merged_memory.get("country_name"),
         "age": merged_memory.get("age"),
-        "summary_jp": summary_jp,
+        "summary_jp": clean_text(raw.get("summary_jp")) or "面接が完了しました。",
         "total_questions": len(history),
-        "overall_score": overall_score,
+        "overall_score": clamp_int(raw.get("overall_score", 65), 0, 100),
         "scores": {
             "fluency": clamp_int(raw_scores.get("fluency", 6), 1, 10),
             "grammar": clamp_int(raw_scores.get("grammar", 6), 1, 10),
@@ -716,25 +641,6 @@ def build_fallback_final_result(merged_memory: Dict[str, Any], history: List[Dic
     avg_score_10 = round(mean(scores), 1) if scores else 0.0
     overall_score = clamp_int(avg_score_10 * 10, 0, 100)
     pass_fail = "PASS" if overall_score >= 60 else "FAIL"
-
-    strengths: List[str] = []
-    weaknesses: List[str] = []
-    tips: List[str] = []
-
-    if merged_memory.get("candidate_name"):
-        strengths.append("Self introduction was understood.")
-    else:
-        weaknesses.append("Name was not clearly understood.")
-
-    if overall_score >= 70:
-        strengths.append("Basic answers were mostly clear.")
-    else:
-        weaknesses.append("Some answers were too short or unclear.")
-
-    tips.append("Use one or two extra sentences in each answer.")
-    tips.append("Try polite endings like です and ます.")
-    tips.append("Practice speaking slowly and clearly.")
-
     return {
         "candidate_name": merged_memory.get("candidate_name"),
         "country_name": merged_memory.get("country_name"),
@@ -749,61 +655,13 @@ def build_fallback_final_result(merged_memory: Dict[str, Any], history: List[Dic
             "relevance": clamp_int(round(avg_score_10 + 1), 1, 10),
         },
         "pass_fail": pass_fail,
-        "strengths": strengths,
-        "weaknesses": weaknesses,
-        "tips": tips,
+        "strengths": ["Basic answers were captured."] if merged_memory.get("candidate_name") else [],
+        "weaknesses": ["Some answers were too short."] if overall_score < 70 else [],
+        "tips": ["Speak slowly and clearly.", "Use one extra sentence in each answer."],
         "answers": history,
     }
 
 
-
-def should_finish_dynamically(memory: Dict[str, Any], answer_score: int, question_no: int, llm_requested_finish: bool) -> bool:
-    history = list(memory.get("answers_so_far", []))
-    scores = [int(x.get("answer_score", 0)) for x in history if x.get("answer_score") is not None]
-    avg_score = mean(scores) if scores else float(answer_score)
-    min_questions = int(memory.get("min_questions", MIN_DYNAMIC_QUESTIONS))
-    max_questions = int(memory.get("max_questions", MAX_DYNAMIC_QUESTIONS))
-
-    # Never finish before minimum questions unless there is a serious technical issue handled elsewhere
-    if question_no < min_questions:
-        return False
-
-    if llm_requested_finish:
-        return True
-
-    # Weak candidate: finish early
-    if question_no >= min_questions and avg_score < 3.8:
-        return True
-
-    # Medium candidate: end around 6 questions
-    if question_no >= 6 and avg_score < 5.6:
-        return True
-
-    # Good candidate: continue a bit longer
-    if question_no >= 8 and avg_score < 7.0:
-        return True
-
-    # Strong candidate: allow up to max
-    if question_no >= max_questions:
-        return True
-
-    return False
-
-
-def build_repeat_prompt(memory: Dict[str, Any], question_jp: str) -> str:
-    name = memory.get("candidate_name")
-    prefix = f"{name}さん、" if name else ""
-    return f"{prefix}声が小さいです。もう少し大きい声で、もう一度お願いします。もう一度聞きます。{question_jp}"
-
-
-def build_speech_text(memory: Dict[str, Any], feedback_jp: str, next_question_jp: str) -> str:
-    name = memory.get("candidate_name")
-    if next_question_jp.startswith("すみません") or next_question_jp.startswith("声が小さい"):
-        return next_question_jp
-    if name and name not in next_question_jp:
-        return f"{name}さん、ありがとうございます。{next_question_jp}"
-    return f"{feedback_jp} {next_question_jp}".strip()
-
 def ensure_string_list(value: Any) -> List[str]:
     if not isinstance(value, list):
         return []