Update app.py

app.py

@@ -1243,37 +1243,29 @@ async def process_text_chat(message: str, web_search_enabled: bool, target_langu
                           system_prompt: str) -> Dict[str, str]:
     """Process text chat using GPT-4o-mini model"""
     try:
-        # Prepare system message
-        base_instructions = system_prompt or "You are a helpful assistant."
-        
-        # Add strong language instructions if language is selected
+        # If target language is set, override system prompt completely
         if target_language:
             language_name = SUPPORTED_LANGUAGES.get(target_language, target_language)
             
-            # Language-specific instructions
+            # Create system prompt in target language
             if target_language == "en":
-                lang_specific = "\nYou MUST respond in English ONLY. Never use Korean or any other language."
+                base_instructions = f"You are a helpful assistant. You speak ONLY English. Never use Korean or any other language. {system_prompt}"
+                user_prefix = "Please respond in English: "
             elif target_language == "ja":
-                lang_specific = "\n日本語でのみ応答してください。韓国語や他の言語は使用しないでください。"
+                base_instructions = f"あなたは親切なアシスタントです。日本語のみを話します。韓国語や他の言語は絶対に使用しません。{system_prompt}"
+                user_prefix = "日本語で答えてください: "
             elif target_language == "zh":
-                lang_specific = "\n只能用中文回答。不要使用韩语或其他任何语言。"
+                base_instructions = f"你是一个乐于助人的助手。你只说中文。绝不使用韩语或其他语言。{system_prompt}"
+                user_prefix = "请用中文回答: "
             elif target_language == "es":
-                lang_specific = "\nDebe responder SOLO en español. Nunca use coreano u otros idiomas."
-            elif target_language == "fr":
-                lang_specific = "\nVous devez répondre UNIQUEMENT en français. N'utilisez jamais le coréen ou d'autres langues."
-            elif target_language == "de":
-                lang_specific = "\nSie müssen NUR auf Deutsch antworten. Verwenden Sie niemals Koreanisch oder andere Sprachen."
+                base_instructions = f"Eres un asistente útil. Solo hablas español. Nunca uses coreano u otros idiomas. {system_prompt}"
+                user_prefix = "Por favor responde en español: "
             else:
-                lang_specific = f"\nYou MUST respond ONLY in {language_name}. Never use any other language."
-            
-            translation_instructions = (
-                f"\n\nIMPORTANT: Your response language is set to {language_name} ({target_language})."
-                f"{lang_specific}"
-                f"\nEven if the user writes in Korean or another language, you must ALWAYS respond in {language_name}."
-                f"\nThis is a strict requirement. Output language: {language_name} ONLY."
-            )
-            
-            base_instructions = base_instructions + translation_instructions
+                base_instructions = f"You are a helpful assistant that speaks ONLY {language_name}. {system_prompt}"
+                user_prefix = f"Please respond in {language_name}: "
+        else:
+            base_instructions = system_prompt or "You are a helpful assistant."
+            user_prefix = ""
         
         messages = [
             {"role": "system", "content": base_instructions}
@@ -1296,14 +1288,21 @@ async def process_text_chat(message: str, web_search_enabled: bool, target_langu
                     for i, result in enumerate(search_results[:5], 1):
                         search_context += f"{i}. {result['title']}\n{result['description']}\n\n"
                     
+                    # Add search context in target language if set
+                    if target_language:
+                        search_instruction = f"Use this search information but respond in {SUPPORTED_LANGUAGES.get(target_language, target_language)} only: "
+                    else:
+                        search_instruction = "다음 웹 검색 결과를 참고하여 답변하세요: "
+                    
                     messages.append({
                         "role": "system", 
-                        "content": f"다음 웹 검색 결과를 참고하여 답변하세요:\n\n{search_context}"
+                        "content": search_instruction + "\n\n" + search_context
                     })
         
-        messages.append({"role": "user", "content": message})
+        # Add user message with language prefix
+        messages.append({"role": "user", "content": user_prefix + message})
         
-        # Call GPT-4o-mini with strong language enforcement
+        # Call GPT-4o-mini
         response = await client.chat.completions.create(
             model="gpt-4o-mini",
             messages=messages,
@@ -1313,7 +1312,21 @@ async def process_text_chat(message: str, web_search_enabled: bool, target_langu
         
         response_text = response.choices[0].message.content
         
-        # Debug logging
+        # Final check - remove any Korean if target language is not Korean
+        if target_language and target_language != "ko":
+            import re
+            if re.search(r'[가-힣]', response_text):
+                print(f"[TEXT CHAT] WARNING: Korean detected in response for {target_language}")
+                # Try again with stronger prompt
+                messages[-1] = {"role": "user", "content": f"ONLY {SUPPORTED_LANGUAGES.get(target_language, target_language)}, NO KOREAN: {message}"}
+                retry_response = await client.chat.completions.create(
+                    model="gpt-4o-mini",
+                    messages=messages,
+                    temperature=0.3,
+                    max_tokens=2000
+                )
+                response_text = retry_response.choices[0].message.content
+        
         print(f"[TEXT CHAT] Target language: {target_language}")
         print(f"[TEXT CHAT] Response preview: {response_text[:100]}...")
         
@@ -1455,19 +1468,51 @@ class OpenAIHandler(AsyncStreamHandler):
             # 2. Translate with GPT-4o-mini
             target_lang_name = SUPPORTED_LANGUAGES.get(self.interpretation_language, self.interpretation_language)
             
-            # Create very specific translation prompt
-            if self.interpretation_language == "en":
-                system_prompt = "You are a translator. Translate Korean to English. Output ONLY the English translation, nothing else."
-            elif self.interpretation_language == "ja":
-                system_prompt = "You are a translator. Translate Korean to Japanese. Output ONLY the Japanese translation (日本語のみ), nothing else."
-            elif self.interpretation_language == "zh":
-                system_prompt = "You are a translator. Translate Korean to Chinese. Output ONLY the Chinese translation (只输出中文), nothing else."
-            elif self.interpretation_language == "es":
-                system_prompt = "You are a translator. Translate Korean to Spanish. Output ONLY the Spanish translation (solo español), nothing else."
-            else:
-                system_prompt = f"You are a translator. Translate Korean to {target_lang_name}. Output ONLY the {target_lang_name} translation, nothing else."
+            # Create very explicit translation examples
+            translation_examples = {
+                "en": {
+                    "안녕하세요": "Hello",
+                    "감사합니다": "Thank you",
+                    "오늘 날씨가 좋네요": "The weather is nice today"
+                },
+                "ja": {
+                    "안녕하세요": "こんにちは",
+                    "감사합니다": "ありがとうございます", 
+                    "오늘 날씨가 좋네요": "今日はいい天気ですね"
+                },
+                "zh": {
+                    "안녕하세요": "你好",
+                    "감사합니다": "谢谢",
+                    "오늘 날씨가 좋네요": "今天天气很好"
+                },
+                "es": {
+                    "안녕하세요": "Hola",
+                    "감사합니다": "Gracias",
+                    "오늘 날씨가 좋네요": "El clima está agradable hoy"
+                }
+            }
+            
+            examples = translation_examples.get(self.interpretation_language, translation_examples["en"])
+            examples_text = "\n".join([f'"{k}" → "{v}"' for k, v in examples.items()])
+            
+            # Ultra-specific prompt
+            system_prompt = f"""You are a Korean to {target_lang_name} translator.
+
+STRICT RULES:
+1. Output ONLY the {target_lang_name} translation
+2. Do NOT output Korean
+3. Do NOT add explanations
+4. Do NOT answer questions
+5. Just translate
+
+Examples:
+{examples_text}
+
+Now translate the Korean text to {target_lang_name}. Output ONLY the translation in {target_lang_name}:"""
             
             print(f"[INTERPRETATION] Translating to {target_lang_name}...")
+            print(f"[INTERPRETATION] System prompt: {system_prompt}")
+            
             translation_response = await self.client.chat.completions.create(
                 model="gpt-4o-mini",
                 messages=[
@@ -1477,26 +1522,33 @@ class OpenAIHandler(AsyncStreamHandler):
                     },
                     {
                         "role": "user",
-                        "content": user_text
+                        "content": f"Translate this Korean to {target_lang_name}: {user_text}"
                     }
                 ],
-                temperature=0.1,  # Lower temperature for more literal translation
+                temperature=0.1,  # Very low temperature
                 max_tokens=200
             )
             
             translated_text = translation_response.choices[0].message.content.strip()
+            
+            # Remove any Korean characters if they accidentally appear
+            import re
+            if re.search(r'[가-힣]', translated_text):
+                print(f"[INTERPRETATION] WARNING: Korean characters detected in translation: {translated_text}")
+                # Try to extract only non-Korean parts
+                translated_text = re.sub(r'[가-힣\s]+', ' ', translated_text).strip()
+            
             print(f"[INTERPRETATION] Translated: {translated_text}")
             
             # 3. Generate speech with TTS
-            print("[INTERPRETATION] Generating speech...")
+            print(f"[INTERPRETATION] Generating speech for text: {translated_text}")
             
-            # Select appropriate voice for the language
-            # Using voices that work better for each language
+            # Select appropriate voice and ensure it speaks the target language
             voice_map = {
-                "en": "nova",      # Nova has clear English pronunciation
-                "es": "nova",      # Nova works well for Spanish
-                "fr": "shimmer",   # Shimmer works well for French
-                "de": "onyx",      # Onyx works well for German
+                "en": "alloy",     # Alloy is native English speaker
+                "es": "nova",      # Nova handles Spanish well
+                "fr": "shimmer",   # Shimmer handles French well
+                "de": "echo",      # Echo handles German well
                 "ja": "nova",      # Nova can handle Japanese
                 "zh": "nova",      # Nova can handle Chinese
                 "ko": "nova",      # Nova can handle Korean
@@ -1505,13 +1557,29 @@ class OpenAIHandler(AsyncStreamHandler):
             
             print(f"[INTERPRETATION] Using voice: {selected_voice} for language: {self.interpretation_language}")
             
-            tts_response = await self.client.audio.speech.create(
-                model="tts-1",
-                voice=selected_voice,
-                input=translated_text,
-                response_format="pcm",  # PCM format for direct playback
-                speed=1.0
-            )
+            # For some languages, we might need to add pronunciation hints
+            if self.interpretation_language == "en" and re.search(r'[가-힣]', translated_text):
+                print("[INTERPRETATION] ERROR: Korean characters in English translation!")
+                translated_text = "Translation error occurred"
+            
+            try:
+                tts_response = await self.client.audio.speech.create(
+                    model="tts-1",
+                    voice=selected_voice,
+                    input=translated_text,
+                    response_format="pcm",  # PCM format for direct playback
+                    speed=1.0
+                )
+            except Exception as tts_error:
+                print(f"[INTERPRETATION] TTS Error: {tts_error}")
+                # If TTS fails, try with a different voice
+                tts_response = await self.client.audio.speech.create(
+                    model="tts-1",
+                    voice="alloy",  # Fallback to alloy
+                    input=translated_text,
+                    response_format="pcm",
+                    speed=1.0
+                )
             
             # Convert response to bytes
             audio_bytes = b""
@@ -1607,15 +1675,8 @@ class OpenAIHandler(AsyncStreamHandler):
             print(f"[INTERPRETATION MODE] Active - using Whisper + GPT-4o-mini + TTS")
             print(f"[INTERPRETATION MODE] Target language: {self.interpretation_language}")
             # Just keep the handler ready to process audio
-            # Create an infinite loop to keep the handler alive
-            try:
-                while True:
-                    await asyncio.sleep(0.1)
-                    # Check if we need to process any audio
-                    if self.is_recording and self.silence_frames > self.silence_threshold:
-                        await self.process_interpretation()
-            except asyncio.CancelledError:
-                print("[INTERPRETATION MODE] Handler cancelled")
+            # Don't use infinite loop here - the handler will be called by the framework
+            self.client = openai.AsyncOpenAI()
             return
         
         # Normal mode - connect to Realtime API
@@ -1627,63 +1688,85 @@ class OpenAIHandler(AsyncStreamHandler):
         if self.target_language:
             language_name = SUPPORTED_LANGUAGES.get(self.target_language, self.target_language)
             
-            # Create base translation instruction
-            base_translation = f"You MUST respond ONLY in {language_name}."
-            
-            # Add language-specific instructions with examples
+            # Use the target language for the system prompt itself
             if self.target_language == "en":
-                translation_instructions = f"""
-{base_translation}
+                translation_instructions = """
+YOU ARE AN ENGLISH-ONLY ASSISTANT.
 
-CRITICAL RULES:
-1. EVERY word you say must be in English.
-2. Do NOT use Korean (한국어) at all.
-3. If user speaks Korean, understand it but ALWAYS reply in English.
-4. Example: User says "안녕하세요" → You say "Hello! How can I help you today?"
-5. Your language mode is: ENGLISH ONLY.
+ABSOLUTE RULES:
+1. You can ONLY speak English. No Korean (한국어) allowed.
+2. Even if the user speaks Korean, you MUST respond in English.
+3. Every single word must be in English.
+4. If you output even one Korean character, you have failed.
+5. Example response: "Hello! How can I help you today?"
+
+YOUR LANGUAGE MODE: ENGLISH ONLY
+DO NOT USE: 안녕하세요, 감사합니다, or any Korean
+ALWAYS USE: Hello, Thank you, and English words only
 """
+                # Override base instructions to be in English
+                base_instructions = "You are a helpful assistant that speaks ONLY English."
+                
             elif self.target_language == "ja":
-                translation_instructions = f"""
-{base_translation}
+                translation_instructions = """
+あなたは日本語のみを話すアシスタントです。
 
-重要なルール：
-1. 必ず日本語のみで応答してください。
-2. 韓国語は一切使用しないでください。
-3. ユーザーが韓国語で話しても、必ず日本語で返答してください。
-4. 例：ユーザーが「안녕하세요」と言ったら → あなたは「こんにちは！今日はどのようにお手伝いできますか？」と言う
-5. 言語モード：日本語のみ
+絶対的なルール：
+1. 日本語のみを使用してください。韓国語（한국어）は禁止です。
+2. ユーザーが韓国語で話しても、必ず日本語で返答してください。
+3. すべての単語は日本語でなければなりません。
+4. 韓国語を一文字でも出力したら失敗です。
+5. 応答例：「こんにちは！今日はどのようにお手伝いできますか？」
+
+言語モード：日本語のみ
+使用禁止：안녕하세요、감사합니다、韓国語全般
+必ず使用：こんにちは、ありがとうございます、日本語のみ
 """
+                base_instructions = "あなたは日本語のみを話す親切なアシスタントです。"
+                
             elif self.target_language == "zh":
-                translation_instructions = f"""
-{base_translation}
+                translation_instructions = """
+你是一个只说中文的助手。
+
+绝对规则：
+1. 只能使用中文。禁止使用韩语（한국어）。
+2. 即使用户说韩语，也必须用中文回复。
+3. 每个字都必须是中文。
+4. 如果输出任何韩语字符，就是失败。
+5. 回复示例："你好！我今天能为您做什么？"
 
-重要规则：
-1. 必须只用中文回答。
-2. 绝对不要使用韩语。
-3. 即使用户说韩语，也必须用中文回复。
-4. 例如：用户说"안녕하세요" → 你说"你好！我能为您做什么？"
-5. 语言模式：仅中文
+语言模式：仅中文
+禁止使用：안녕하세요、감사합니다、任何韩语
+必须使用：你好、谢谢、只用中文
 """
+                base_instructions = "你是一个只说中文的友好助手。"
+                
             elif self.target_language == "es":
-                translation_instructions = f"""
-{base_translation}
+                translation_instructions = """
+ERES UN ASISTENTE QUE SOLO HABLA ESPAÑOL.
+
+REGLAS ABSOLUTAS:
+1. Solo puedes hablar español. No se permite coreano (한국어).
+2. Incluso si el usuario habla coreano, DEBES responder en español.
+3. Cada palabra debe estar en español.
+4. Si produces aunque sea un carácter coreano, has fallado.
+5. Respuesta ejemplo: "¡Hola! ¿Cómo puedo ayudarte hoy?"
 
-REGLAS CRÍTICAS:
-1. TODAS tus palabras deben estar en español.
-2. NO uses coreano en absoluto.
-3. Si el usuario habla coreano, entiéndelo pero SIEMPRE responde en español.
-4. Ejemplo: Usuario dice "안녕하세요" → Tú dices "¡Hola! ¿Cómo puedo ayudarte hoy?"
-5. Modo de idioma: SOLO ESPAÑOL
+MODO DE IDIOMA: SOLO ESPAÑOL
+NO USAR: 안녕하세요, 감사합니다, o cualquier coreano
+SIEMPRE USAR: Hola, Gracias, y solo palabras en español
 """
+                base_instructions = "Eres un asistente útil que habla SOLO español."
             else:
                 translation_instructions = f"""
-{base_translation}
+YOU MUST ONLY SPEAK {language_name.upper()}.
 
 RULES:
-1. You must ONLY speak in {language_name}.
-2. NEVER use Korean or any other language.
-3. Always respond in {language_name} regardless of what language the user speaks.
+1. Output only in {language_name}
+2. Never use Korean
+3. Always respond in {language_name}
 """
+                base_instructions = f"You are a helpful assistant that speaks ONLY {language_name}."
         else:
             translation_instructions = ""
         
@@ -1720,11 +1803,24 @@ RULES:
                 "When in doubt, USE web_search. It's better to search and provide accurate information "
                 "than to guess or use outdated information."
             )
-            instructions = base_instructions + translation_instructions + search_instructions
+            
+            # Combine all instructions
+            if translation_instructions:
+                # Translation instructions already include base_instructions
+                instructions = translation_instructions + search_instructions
+            else:
+                instructions = base_instructions + search_instructions
         else:
-            instructions = base_instructions + translation_instructions
+            # No web search
+            if translation_instructions:
+                instructions = translation_instructions
+            else:
+                instructions = base_instructions
         
-        print(f"[NORMAL MODE] Instructions: {instructions[:200]}...")
+        print(f"[NORMAL MODE] Base instructions: {base_instructions[:100]}...")
+        print(f"[NORMAL MODE] Translation instructions: {translation_instructions[:200] if translation_instructions else 'None'}...")
+        print(f"[NORMAL MODE] Combined instructions length: {len(instructions)}")
+        print(f"[NORMAL MODE] Target language: {self.target_language}")
         
         async with self.client.beta.realtime.connect(
             model="gpt-4o-mini-realtime-preview-2024-12-17"
@@ -1734,42 +1830,39 @@ RULES:
                 "turn_detection": {"type": "server_vad"},
                 "instructions": instructions,
                 "tools": tools,
-                "tool_choice": "auto" if tools else "none"
+                "tool_choice": "auto" if tools else "none",
+                "temperature": 0.7,
+                "max_response_output_tokens": 4096,
+                "modalities": ["text", "audio"],
+                "voice": "alloy"  # Default voice
             }
             
             # Use appropriate voice for the language
             if self.target_language:
-                # Use voice that works better for each language
+                # Force language through multiple mechanisms
+                # 1. Use voice that's known to work well with the language
                 voice_map = {
-                    "en": "nova",      # Nova has clear pronunciation
-                    "es": "nova",      # Nova works well for Spanish
+                    "en": "nova",      # Nova has clearer English
+                    "es": "nova",      # Nova works for Spanish
                     "fr": "shimmer",   # Shimmer for French
-                    "de": "onyx",      # Onyx for German
-                    "ja": "nova",      # Nova can handle Japanese
-                    "zh": "nova",      # Nova can handle Chinese
-                    "ko": "nova",      # Nova can handle Korean
+                    "de": "echo",      # Echo for German  
+                    "ja": "alloy",     # Alloy can do Japanese
+                    "zh": "alloy",     # Alloy can do Chinese
+                    "ko": "nova",      # Nova for Korean
                 }
                 session_update["voice"] = voice_map.get(self.target_language, "nova")
                 
-                # Force output language settings
+                # 2. Add language to modalities (experimental)
                 session_update["modalities"] = ["text", "audio"]
-                session_update["output_audio_format"] = "pcm16"
                 
-                # Add extra language enforcement in system message
-                if self.target_language == "en":
-                    extra_instruction = "\n\nREMINDER: Speak in English only. 英語のみで話してください。"
-                elif self.target_language == "ja":
-                    extra_instruction = "\n\nREMINDER: 日本語のみで話してください。Speak in Japanese only."
-                elif self.target_language == "zh":
-                    extra_instruction = "\n\nREMINDER: 只说中文。Speak in Chinese only."
-                else:
-                    extra_instruction = ""
+                # 3. Set output format
+                session_update["output_audio_format"] = "pcm16"
                 
-                session_update["instructions"] = instructions + extra_instruction
+                # 4. Add language hint to the system (if supported by API)
+                if self.target_language in ["en", "es", "fr", "de", "ja", "zh"]:
+                    session_update["language"] = self.target_language  # Try setting language directly
                 
-                print(f"[TRANSLATION MODE] Target language: {self.target_language}")
-                print(f"[TRANSLATION MODE] Voice: {session_update['voice']}")
-                print(f"[TRANSLATION MODE] Instructions preview: {session_update['instructions'][:200]}...")
+                print(f"[TRANSLATION MODE] Session update: {json.dumps(session_update, indent=2)}")
             
             await conn.session.update(session=session_update)
             self.connection = conn