Private-AI

Running

App Files Files Community

seawolf2357 commited on 18 days ago

Commit

21a8848

verified ·

1 Parent(s): 78579ce

Update app-backup3.py

Browse files

Files changed (1) hide show

app-backup3.py +125 -553

app-backup3.py CHANGED Viewed

@@ -162,20 +162,6 @@ HTML_CONTENT = """<!DOCTYPE html>
             gap: 15px;
             margin-bottom: 15px;
         }
-        .interpretation-section {
-            display: flex;
-            flex-direction: column;
-            gap: 15px;
-            padding: 15px;
-            background-color: var(--dark-bg);
-            border-radius: 8px;
-            margin-top: 15px;
-        }
-        .interpretation-info {
-            font-size: 13px;
-            color: #999;
-            margin-top: 5px;
-        }
         .setting-item {
             display: flex;
             align-items: center;
@@ -318,14 +304,10 @@ HTML_CONTENT = """<!DOCTYPE html>
             padding: 10px;
             margin-bottom: 10px;
         }
-        .message.assistant.interpretation {
-            background: linear-gradient(135deg, #1a5a3e, #2e7d32);
-            font-style: italic;
-        }
-        .interpretation-arrow {
-            color: #4caf50;
-            font-weight: bold;
-            margin: 0 10px;
         }
         .controls {
             text-align: center;
@@ -513,11 +495,6 @@ HTML_CONTENT = """<!DOCTYPE html>
             background-color: var(--secondary-color);
             border-radius: 50%;
         }
-        .language-info {
-            font-size: 12px;
-            color: #888;
-            margin-left: 5px;
-        }
     </style>
 </head>
@@ -542,7 +519,7 @@ HTML_CONTENT = """<!DOCTYPE html>
         <div class="main-content">
             <div class="sidebar">
                 <div class="settings-section">
-                    <h3 style="margin: 0 0 15px 0; color: var(--primary-color);">설정</h3>
                     <div class="settings-grid">
                         <div class="setting-item">
                             <span class="setting-label">웹 검색</span>
@@ -551,7 +528,7 @@ HTML_CONTENT = """<!DOCTYPE html>
                             </div>
                         </div>
                         <div class="setting-item">
-                            <span class="setting-label">자동 번역</span>
                             <select id="language-select">
                                 <option value="">비활성화</option>
                                 <option value="ko">한국어 (Korean)</option>
@@ -586,55 +563,6 @@ HTML_CONTENT = """<!DOCTYPE html>
                             </select>
                         </div>
                     </div>
-                    <div class="interpretation-section">
-                        <div class="setting-item">
-                            <span class="setting-label">자동 통역</span>
-                            <div id="interpretation-toggle" class="toggle-switch">
-                                <div class="toggle-slider"></div>
-                            </div>
-                        </div>
-                        <div class="setting-item" id="interpretation-language-container" style="display: none;">
-                            <span class="setting-label">통역 언어</span>
-                            <select id="interpretation-language-select">
-                                <option value="">언어 선택</option>
-                                <option value="ko">한국어 (Korean)</option>
-                                <option value="en">English</option>
-                                <option value="es">Español (Spanish)</option>
-                                <option value="fr">Français (French)</option>
-                                <option value="de">Deutsch (German)</option>
-                                <option value="it">Italiano (Italian)</option>
-                                <option value="pt">Português (Portuguese)</option>
-                                <option value="ru">Русский (Russian)</option>
-                                <option value="ja">日本語 (Japanese)</option>
-                                <option value="zh">中文 (Chinese)</option>
-                                <option value="ar">العربية (Arabic)</option>
-                                <option value="hi">हिन्दी (Hindi)</option>
-                                <option value="nl">Nederlands (Dutch)</option>
-                                <option value="pl">Polski (Polish)</option>
-                                <option value="tr">Türkçe (Turkish)</option>
-                                <option value="vi">Tiếng Việt (Vietnamese)</option>
-                                <option value="th">ไทย (Thai)</option>
-                                <option value="id">Bahasa Indonesia</option>
-                                <option value="sv">Svenska (Swedish)</option>
-                                <option value="da">Dansk (Danish)</option>
-                                <option value="no">Norsk (Norwegian)</option>
-                                <option value="fi">Suomi (Finnish)</option>
-                                <option value="he">עברית (Hebrew)</option>
-                                <option value="uk">Українська (Ukrainian)</option>
-                                <option value="cs">Čeština (Czech)</option>
-                                <option value="el">Ελληνικά (Greek)</option>
-                                <option value="ro">Română (Romanian)</option>
-                                <option value="hu">Magyar (Hungarian)</option>
-                                <option value="ms">Bahasa Melayu (Malay)</option>
-                            </select>
-                        </div>
-                    </div>
-                    <div class="interpretation-info" id="interpretation-info" style="display: none;">
-                        <strong>통역 모드 안내:</strong><br>
-                        • 음성으로 말하면 선택한 언어로 자동 통역됩니다<br>
-                        • Whisper + GPT-4o-mini + TTS를 사용합니다<br>
-                        • 말을 마치고 잠시 기다리면 통역이 시작됩니다
-                    </div>
                     <div class="text-input-section">
                         <label for="system-prompt" class="setting-label">시스템 프롬프트:</label>
                         <textarea id="system-prompt" placeholder="AI 어시스턴트의 성격, 역할, 행동 방식을 정의하세요...">You are a helpful assistant. Respond in a friendly and professional manner.</textarea>
@@ -667,8 +595,6 @@ HTML_CONTENT = """<!DOCTYPE html>
         let webrtc_id;
         let webSearchEnabled = false;
         let selectedLanguage = "";
-        let interpretationMode = false;
-        let interpretationLanguage = "";
         let systemPrompt = "You are a helpful assistant. Respond in a friendly and professional manner.";
         const audioOutput = document.getElementById('audio-output');
         const startButton = document.getElementById('start-button');
@@ -678,10 +604,6 @@ HTML_CONTENT = """<!DOCTYPE html>
         const statusText = document.getElementById('status-text');
         const searchToggle = document.getElementById('search-toggle');
         const languageSelect = document.getElementById('language-select');
-        const interpretationToggle = document.getElementById('interpretation-toggle');
-        const interpretationLanguageSelect = document.getElementById('interpretation-language-select');
-        const interpretationLanguageContainer = document.getElementById('interpretation-language-container');
-        const interpretationInfo = document.getElementById('interpretation-info');
         const systemPromptInput = document.getElementById('system-prompt');
         const textInput = document.getElementById('text-input');
         let audioLevel = 0;
@@ -703,86 +625,6 @@ HTML_CONTENT = """<!DOCTYPE html>
             console.log('Selected language:', selectedLanguage);
         });
-        // Interpretation mode toggle
-        interpretationToggle.addEventListener('click', () => {
-            if (!interpretationMode) {
-                // Turning ON interpretation mode
-                interpretationLanguageContainer.style.display = 'flex';
-                interpretationInfo.style.display = 'block';
-                // Show language selector first
-                showError('통역 언어를 선택해주세요.');
-                interpretationToggle.classList.remove('active');
-                // Don't actually enable interpretation mode until language is selected
-                return;
-            } else {
-                // Turning OFF interpretation mode
-                interpretationMode = false;
-                interpretationToggle.classList.remove('active');
-                interpretationLanguageContainer.style.display = 'none';
-                interpretationInfo.style.display = 'none';
-                interpretationLanguage = '';
-                interpretationLanguageSelect.value = '';
-                // Re-enable other features
-                languageSelect.disabled = false;
-                searchToggle.style.opacity = '1';
-                searchToggle.style.pointerEvents = 'auto';
-                textInput.disabled = false;
-                textInput.placeholder = '텍스트 메시지를 입력하세요...';
-                sendButton.style.display = 'block';
-                console.log('Interpretation mode disabled');
-                // If connected, restart to apply normal mode
-                if (peerConnection && peerConnection.connectionState === 'connected') {
-                    showError('일반 모드로 전환하기 위해 연결을 다시 시작합니다.');
-                    stop();
-                    setTimeout(() => {
-                        setupWebRTC();
-                    }, 500);
-                }
-            }
-            console.log('Interpretation mode:', interpretationMode);
-        });
-        // Interpretation language selection
-        interpretationLanguageSelect.addEventListener('change', () => {
-            interpretationLanguage = interpretationLanguageSelect.value;
-            console.log('Interpretation language:', interpretationLanguage);
-            if (interpretationLanguage && !interpretationMode) {
-                // Now actually enable interpretation mode
-                interpretationMode = true;
-                interpretationToggle.classList.add('active');
-                // Disable other features
-                languageSelect.value = '';
-                selectedLanguage = '';
-                languageSelect.disabled = true;
-                searchToggle.classList.remove('active');
-                webSearchEnabled = false;
-                searchToggle.style.opacity = '0.5';
-                searchToggle.style.pointerEvents = 'none';
-                textInput.disabled = true;
-                textInput.placeholder = '통역 모드에서는 텍스트 입력이 지원되지 않습니다';
-                sendButton.style.display = 'none';
-                console.log('Interpretation mode enabled with language:', interpretationLanguage);
-                // If already connected, restart the connection with new settings
-                if (peerConnection && peerConnection.connectionState === 'connected') {
-                    showError('통역 모드 설정을 적용하기 위해 연결을 다시 시작합니다.');
-                    stop();
-                    setTimeout(() => {
-                        setupWebRTC();
-                    }, 500);
-                }
-            }
-        });
         // System prompt update
         systemPromptInput.addEventListener('input', () => {
             systemPrompt = systemPromptInput.value || "You are a helpful assistant. Respond in a friendly and professional manner.";
@@ -802,12 +644,6 @@ HTML_CONTENT = """<!DOCTYPE html>
             const message = textInput.value.trim();
             if (!message) return;
-            // Don't allow text messages in interpretation mode
-            if (interpretationMode) {
-                showError('통역 모드에서는 텍스트 입력이 지원되지 않습니다.');
-                return;
-            }
             // Add user message to chat
             addMessage('user', message);
             textInput.value = '';
@@ -861,18 +697,14 @@ HTML_CONTENT = """<!DOCTYPE html>
             statusDot.className = 'status-dot ' + state;
             if (state === 'connected') {
                 statusText.textContent = '연결됨';
-                if (!interpretationMode) {
-                    sendButton.style.display = 'block';
-                }
                 isVoiceActive = true;
             } else if (state === 'connecting') {
                 statusText.textContent = '연결 중...';
                 sendButton.style.display = 'none';
             } else {
                 statusText.textContent = '연결 대기 중';
-                if (!interpretationMode) {
-                    sendButton.style.display = 'block';  // Show send button even when disconnected for text chat
-                }
                 isVoiceActive = false;
             }
         }
@@ -1018,9 +850,7 @@ HTML_CONTENT = """<!DOCTYPE html>
                     webrtc_id: webrtc_id,
                     web_search_enabled: webSearchEnabled,
                     target_language: selectedLanguage,
-                    system_prompt: systemPrompt,
-                    interpretation_mode: interpretationMode,
-                    interpretation_language: interpretationLanguage
                 });
                 const response = await fetch('/webrtc/offer', {
@@ -1032,9 +862,7 @@ HTML_CONTENT = """<!DOCTYPE html>
                         webrtc_id: webrtc_id,
                         web_search_enabled: webSearchEnabled,
                         target_language: selectedLanguage,
-                        system_prompt: systemPrompt,
-                        interpretation_mode: interpretationMode,
-                        interpretation_language: interpretationLanguage
                     })
                 });
                 const serverResponse = await response.json();
@@ -1051,30 +879,8 @@ HTML_CONTENT = """<!DOCTYPE html>
                     const eventJson = JSON.parse(event.data);
                     let content = eventJson.content;
-                    // Debug logging for interpretation mode
-                    if (interpretationMode) {
-                        console.log('[INTERPRETATION OUTPUT]', {
-                            content: content,
-                            language: eventJson.language,
-                            mode: eventJson.mode,
-                            expectedLanguage: interpretationLanguage
-                        });
-                    }
                     if (selectedLanguage && eventJson.language) {
                         content += ` <span class="language-info">[${eventJson.language}]</span>`;
-                    } else if (interpretationMode && eventJson.language) {
-                        // In interpretation mode, show the translation process
-                        if (content.includes('→')) {
-                            // Format: "Korean text → English text"
-                            const parts = content.split('→');
-                            if (parts.length === 2) {
-                                content = `<span style="color: #999;">${parts[0].trim()}</span>` +
-                                         `<span class="interpretation-arrow">→</span>` +
-                                         `<strong>${parts[1].trim()}</strong>`;
-                            }
-                        }
-                        content += ` <span class="language-info">[통역: ${eventJson.language}]</span>`;
                     }
                     addMessage("assistant", content);
                 });
@@ -1095,11 +901,6 @@ HTML_CONTENT = """<!DOCTYPE html>
             const messageDiv = document.createElement('div');
             messageDiv.classList.add('message', role);
-            // Check if it's an interpretation message
-            if (interpretationMode && role === 'assistant' && content.includes('→')) {
-                messageDiv.classList.add('interpretation');
-            }
             if (content.includes('<span')) {
                 messageDiv.innerHTML = content;
             } else {
@@ -1108,17 +909,35 @@ HTML_CONTENT = """<!DOCTYPE html>
             chatMessages.appendChild(messageDiv);
             chatMessages.scrollTop = chatMessages.scrollHeight;
         }
         function stop() {
             if (animationFrame) {
                 cancelAnimationFrame(animationFrame);
             }
             if (audioContext) {
                 audioContext.close();
                 audioContext = null;
                 analyser = null;
                 audioSource = null;
             }
             if (peerConnection) {
                 if (peerConnection.getTransceivers) {
                     peerConnection.getTransceivers().forEach(transceiver => {
                         if (transceiver.stop) {
@@ -1126,17 +945,46 @@ HTML_CONTENT = """<!DOCTYPE html>
                         }
                     });
                 }
                 if (peerConnection.getSenders) {
                     peerConnection.getSenders().forEach(sender => {
-                        if (sender.track && sender.track.stop) sender.track.stop();
                     });
                 }
-                console.log('closing');
                 peerConnection.close();
             }
-            dataChannel = null;
-            updateButtonState();
             audioLevel = 0;
         }
         startButton.addEventListener('click', () => {
             console.log('clicked');
@@ -1149,7 +997,7 @@ HTML_CONTENT = """<!DOCTYPE html>
             }
         });
-        // Initialize send button visibility on page load
         window.addEventListener('DOMContentLoaded', () => {
             sendButton.style.display = 'block';
         });
@@ -1227,18 +1075,6 @@ def update_chatbot(chatbot: list[dict], response: ResponseAudioTranscriptDoneEve
     return chatbot
-def get_translation_instructions(target_language: str) -> str:
-    """Get instructions for translation based on target language"""
-    if not target_language:
-        return ""
-    language_name = SUPPORTED_LANGUAGES.get(target_language, target_language)
-    return (
-        f"\n\nIMPORTANT: You must respond in {language_name} ({target_language}). "
-        f"Translate all your responses to {language_name}."
-    )
 async def process_text_chat(message: str, web_search_enabled: bool, target_language: str,
                           system_prompt: str) -> Dict[str, str]:
     """Process text chat using GPT-4o-mini model"""
@@ -1342,8 +1178,7 @@ async def process_text_chat(message: str, web_search_enabled: bool, target_langu
 class OpenAIHandler(AsyncStreamHandler):
     def __init__(self, web_search_enabled: bool = False, target_language: str = "",
-                 system_prompt: str = "", webrtc_id: str = None,
-                 interpretation_mode: bool = False, interpretation_language: str = "") -> None:
         super().__init__(
             expected_layout="mono",
             output_sample_rate=SAMPLE_RATE,
@@ -1360,19 +1195,9 @@ class OpenAIHandler(AsyncStreamHandler):
         self.web_search_enabled = web_search_enabled
         self.target_language = target_language
         self.system_prompt = system_prompt
-        self.interpretation_mode = interpretation_mode
-        self.interpretation_language = interpretation_language
-        # For interpretation mode
-        self.audio_buffer = []
-        self.is_recording = False
-        self.silence_frames = 0
-        self.silence_threshold = 20  # Reduced for faster response (20 frames = ~0.4 seconds)
-        self.min_audio_length = 10  # Minimum frames to consider as speech
-        print(f"Handler created with web_search_enabled={web_search_enabled}, "
-              f"target_language={target_language}, webrtc_id={webrtc_id}, "
-              f"interpretation_mode={interpretation_mode}, interpretation_language={interpretation_language}")
     def copy(self):
         # Get the most recent settings
@@ -1384,17 +1209,19 @@ class OpenAIHandler(AsyncStreamHandler):
             if recent_ids:
                 recent_id = recent_ids[0]
                 settings = connection_settings[recent_id]
                 return OpenAIHandler(
                     web_search_enabled=settings.get('web_search_enabled', False),
                     target_language=settings.get('target_language', ''),
                     system_prompt=settings.get('system_prompt', ''),
-                    webrtc_id=recent_id,
-                    interpretation_mode=settings.get('interpretation_mode', False),
-                    interpretation_language=settings.get('interpretation_language', '')
                 )
-        print(f"Handler.copy() called - creating new handler with default settings")
-        return OpenAIHandler(web_search_enabled=False, interpretation_mode=False)
     async def search_web(self, query: str) -> str:
         """Perform web search and return formatted results"""
@@ -1429,211 +1256,9 @@ class OpenAIHandler(AsyncStreamHandler):
             )
             await self.connection.response.create()
-    async def process_interpretation(self):
-        """Process audio buffer for interpretation"""
-        if not self.audio_buffer or not self.interpretation_language:
-            return
-        try:
-            print(f"[INTERPRETATION] Processing audio buffer with {len(self.audio_buffer)} frames")
-            # Convert audio buffer to WAV format
-            audio_data = np.concatenate(self.audio_buffer)
-            # Create WAV file in memory
-            wav_buffer = io.BytesIO()
-            with wave.open(wav_buffer, 'wb') as wav_file:
-                wav_file.setnchannels(1)  # Mono
-                wav_file.setsampwidth(2)   # 16-bit
-                wav_file.setframerate(SAMPLE_RATE)
-                wav_file.writeframes(audio_data.tobytes())
-            wav_buffer.seek(0)
-            wav_buffer.name = "audio.wav"
-            # 1. Transcribe with Whisper
-            print("[INTERPRETATION] Transcribing with Whisper...")
-            transcript = await self.client.audio.transcriptions.create(
-                model="whisper-1",
-                file=wav_buffer,
-                language="ko"  # Assuming Korean input
-            )
-            user_text = transcript.text.strip()
-            print(f"[INTERPRETATION] Transcribed: {user_text}")
-            if not user_text:
-                return
-            # 2. Translate with GPT-4o-mini
-            target_lang_name = SUPPORTED_LANGUAGES.get(self.interpretation_language, self.interpretation_language)
-            # 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=[
-                    {
-                        "role": "system",
-                        "content": system_prompt
-                    },
-                    {
-                        "role": "user",
-                        "content": f"Translate this Korean to {target_lang_name}: {user_text}"
-                    }
-                ],
-                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(f"[INTERPRETATION] Generating speech for text: {translated_text}")
-            # Select appropriate voice and ensure it speaks the target language
-            voice_map = {
-                "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
-            }
-            selected_voice = voice_map.get(self.interpretation_language, "nova")
-            print(f"[INTERPRETATION] Using voice: {selected_voice} for language: {self.interpretation_language}")
-            # 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""
-            async for chunk in tts_response.iter_bytes(1024):
-                audio_bytes += chunk
-            # Convert PCM to numpy array (TTS outputs at 24kHz)
-            audio_array = np.frombuffer(audio_bytes, dtype=np.int16)
-            # Send audio in chunks
-            if len(audio_array) > 0:
-                # Split audio into chunks and send
-                chunk_size = 480  # Match our frame size
-                for i in range(0, len(audio_array), chunk_size):
-                    chunk = audio_array[i:i + chunk_size]
-                    if len(chunk) < chunk_size:
-                        # Pad the last chunk if necessary
-                        chunk = np.pad(chunk, (0, chunk_size - len(chunk)), 'constant')
-                    await self.output_queue.put((SAMPLE_RATE, chunk.reshape(1, -1)))
-            # Send transcript event
-            output_data = {
-                "event": type('Event', (), {
-                    'transcript': f"{user_text} → {translated_text}"
-                })(),
-                "language": target_lang_name,
-                "mode": "interpretation"
-            }
-            await self.output_queue.put(AdditionalOutputs(output_data))
-        except Exception as e:
-            print(f"[INTERPRETATION] Error: {e}")
-            import traceback
-            traceback.print_exc()
-            # Send error message to client
-            error_data = {
-                "event": type('Event', (), {
-                    'transcript': f"통역 오류: {str(e)}"
-                })(),
-                "language": "",
-                "mode": "error"
-            }
-            await self.output_queue.put(AdditionalOutputs(error_data))
-        finally:
-            # Clear the audio buffer
-            self.audio_buffer = []
-            self.is_recording = False
-            self.silence_frames = 0
     def get_translation_instructions(self):
         """Get instructions for translation based on target language"""
-        if not self.target_language or self.interpretation_mode:
             return ""
         language_name = SUPPORTED_LANGUAGES.get(self.target_language, self.target_language)
@@ -1644,42 +1269,24 @@ Now translate the Korean text to {target_lang_name}. Output ONLY the translation
         )
     async def start_up(self):
-        """Connect to realtime API or setup interpretation mode"""
         # First check if we have the most recent settings
-        if connection_settings:
-            recent_ids = sorted(connection_settings.keys(),
-                              key=lambda k: connection_settings[k].get('timestamp', 0),
-                              reverse=True)
-            if recent_ids:
-                recent_id = recent_ids[0]
-                settings = connection_settings[recent_id]
                 self.web_search_enabled = settings.get('web_search_enabled', False)
                 self.target_language = settings.get('target_language', '')
                 self.system_prompt = settings.get('system_prompt', '')
-                self.interpretation_mode = settings.get('interpretation_mode', False)
-                self.interpretation_language = settings.get('interpretation_language', '')
-                self.webrtc_id = recent_id
-                print(f"start_up: Updated settings from storage - webrtc_id={self.webrtc_id}, "
-                      f"web_search_enabled={self.web_search_enabled}, target_language={self.target_language}, "
-                      f"interpretation_mode={self.interpretation_mode}")
-                print(f"Handler interpretation settings: mode={self.interpretation_mode}, language={self.interpretation_language}")
-        print(f"Starting up handler with web_search_enabled={self.web_search_enabled}, "
-              f"target_language={self.target_language}, interpretation_mode={self.interpretation_mode}, "
-              f"interpretation_language={self.interpretation_language}")
         self.client = openai.AsyncOpenAI()
-        # If in interpretation mode, don't connect to Realtime API
-        if self.interpretation_mode:
-            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
-            # 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
         # Define the web search function
         tools = []
         base_instructions = self.system_prompt or "You are a helpful assistant."
@@ -1893,18 +1500,18 @@ RULES:
                         ),
                     )
-                # Handle function calls (only in non-interpretation mode)
-                elif event.type == "response.function_call_arguments.start" and not self.interpretation_mode:
                     print(f"Function call started")
                     self.function_call_in_progress = True
                     self.current_function_args = ""
                     self.current_call_id = getattr(event, 'call_id', None)
-                elif event.type == "response.function_call_arguments.delta" and not self.interpretation_mode:
                     if self.function_call_in_progress:
                         self.current_function_args += event.delta
-                elif event.type == "response.function_call_arguments.done" and not self.interpretation_mode:
                     if self.function_call_in_progress:
                         print(f"Function call done, args: {self.current_function_args}")
                         try:
@@ -1940,77 +1547,41 @@ RULES:
                             self.current_call_id = None
     async def receive(self, frame: tuple[int, np.ndarray]) -> None:
-        if self.interpretation_mode:
-            # In interpretation mode, buffer audio and process with Whisper
             _, array = frame
             array = array.squeeze()
-            # Simple voice activity detection
-            audio_level = np.abs(array).mean()
-            if audio_level > 200:  # Lower threshold for better detection
-                if not self.is_recording:
-                    print(f"[INTERPRETATION] Started recording, level: {audio_level:.1f}")
-                self.is_recording = True
-                self.silence_frames = 0
-                self.audio_buffer.append(array)
-            elif self.is_recording:
-                self.silence_frames += 1
-                self.audio_buffer.append(array)
-                # If we've had enough silence, process the audio
-                if self.silence_frames > self.silence_threshold and len(self.audio_buffer) > self.min_audio_length:
-                    print(f"[INTERPRETATION] Silence detected after {len(self.audio_buffer)} frames")
-                    # Process in the background to avoid blocking
-                    asyncio.create_task(self.process_interpretation())
-        else:
-            # Normal mode - use Realtime API
-            if not self.connection:
-                return
-            try:
-                _, array = frame
-                array = array.squeeze()
-                audio_message = base64.b64encode(array.tobytes()).decode("utf-8")
-                await self.connection.input_audio_buffer.append(audio=audio_message)
-            except Exception as e:
-                print(f"Error in receive: {e}")
-                # Connection might be closed, ignore the error
     async def emit(self) -> tuple[int, np.ndarray] | AdditionalOutputs | None:
-        # In interpretation mode, we need to keep checking for audio
-        if self.interpretation_mode:
-            # Use a timeout to prevent blocking forever
-            try:
-                item = await asyncio.wait_for(wait_for_item(self.output_queue), timeout=0.1)
-                return item
-            except asyncio.TimeoutError:
-                return None
-        else:
-            # Normal mode
-            item = await wait_for_item(self.output_queue)
-            # Check if it's a dict with text message
-            if isinstance(item, dict) and item.get('type') == 'text_message':
-                await self.process_text_message(item['content'])
-                return None
-            return item
     async def shutdown(self) -> None:
-        if self.interpretation_mode:
-            # Clean up interpretation mode
-            self.audio_buffer = []
-            self.is_recording = False
-            print("[INTERPRETATION MODE] Shutdown complete")
-        else:
-            # Normal mode - close Realtime API connection
-            if self.connection:
-                await self.connection.close()
-                self.connection = None
 # Create initial handler instance
-handler = OpenAIHandler(web_search_enabled=False, interpretation_mode=False)
 # Create components
 chatbot = gr.Chatbot(type="messages")
@@ -2043,12 +1614,10 @@ async def custom_offer(request: Request):
     web_search_enabled = body.get("web_search_enabled", False)
     target_language = body.get("target_language", "")
     system_prompt = body.get("system_prompt", "")
-    interpretation_mode = body.get("interpretation_mode", False)
-    interpretation_language = body.get("interpretation_language", "")
-    print(f"Custom offer - webrtc_id: {webrtc_id}, web_search_enabled: {web_search_enabled}, "
-          f"target_language: {target_language}, interpretation_mode: {interpretation_mode}, "
-          f"interpretation_language: {interpretation_language}")
     # Store settings with timestamp
     if webrtc_id:
@@ -2056,10 +1625,11 @@ async def custom_offer(request: Request):
             'web_search_enabled': web_search_enabled,
             'target_language': target_language,
             'system_prompt': system_prompt,
-            'interpretation_mode': interpretation_mode,
-            'interpretation_language': interpretation_language,
             'timestamp': asyncio.get_event_loop().time()
         }
     # Remove our custom route temporarily
     custom_route = None
@@ -2069,12 +1639,15 @@ async def custom_offer(request: Request):
             break
     # Forward to stream's offer handler
     response = await stream.offer(body)
     # Re-add our custom route
     if custom_route:
         app.routes.insert(0, custom_route)
     return response
@@ -2130,13 +1703,12 @@ async def outputs(webrtc_id: str):
                     yield f"event: search\ndata: {json.dumps(output.args[0])}\n\n"
                 # Regular transcript event with language info
                 elif isinstance(output.args[0], dict) and 'event' in output.args[0]:
-                    event = output.args[0]['event']
-                    if hasattr(event, 'transcript'):
                         data = {
                             "role": "assistant",
-                            "content": event.transcript,
-                            "language": output.args[0].get('language', ''),
-                            "mode": output.args[0].get('mode', 'normal')
                         }
                         yield f"event: output\ndata: {json.dumps(data)}\n\n"

             gap: 15px;
             margin-bottom: 15px;
         }
         .setting-item {
             display: flex;
             align-items: center;
             padding: 10px;
             margin-bottom: 10px;
         }
+        .language-info {
+            font-size: 12px;
+            color: #888;
+            margin-left: 5px;
         }
         .controls {
             text-align: center;
             background-color: var(--secondary-color);
             border-radius: 50%;
         }
     </style>
 </head>
         <div class="main-content">
             <div class="sidebar">
                 <div class="settings-section">
+                    <h3 style="margin: 0 0 15px 0; color: var(--primary-color);">설정(텍스트 채팅에만 적용)</h3>
                     <div class="settings-grid">
                         <div class="setting-item">
                             <span class="setting-label">웹 검색</span>
                             </div>
                         </div>
                         <div class="setting-item">
+                            <span class="setting-label">다국어 번역 채팅</span>
                             <select id="language-select">
                                 <option value="">비활성화</option>
                                 <option value="ko">한국어 (Korean)</option>
                             </select>
                         </div>
                     </div>
                     <div class="text-input-section">
                         <label for="system-prompt" class="setting-label">시스템 프롬프트:</label>
                         <textarea id="system-prompt" placeholder="AI 어시스턴트의 성격, 역할, 행동 방식을 정의하세요...">You are a helpful assistant. Respond in a friendly and professional manner.</textarea>
         let webrtc_id;
         let webSearchEnabled = false;
         let selectedLanguage = "";
         let systemPrompt = "You are a helpful assistant. Respond in a friendly and professional manner.";
         const audioOutput = document.getElementById('audio-output');
         const startButton = document.getElementById('start-button');
         const statusText = document.getElementById('status-text');
         const searchToggle = document.getElementById('search-toggle');
         const languageSelect = document.getElementById('language-select');
         const systemPromptInput = document.getElementById('system-prompt');
         const textInput = document.getElementById('text-input');
         let audioLevel = 0;
             console.log('Selected language:', selectedLanguage);
         });
         // System prompt update
         systemPromptInput.addEventListener('input', () => {
             systemPrompt = systemPromptInput.value || "You are a helpful assistant. Respond in a friendly and professional manner.";
             const message = textInput.value.trim();
             if (!message) return;
             // Add user message to chat
             addMessage('user', message);
             textInput.value = '';
             statusDot.className = 'status-dot ' + state;
             if (state === 'connected') {
                 statusText.textContent = '연결됨';
+                sendButton.style.display = 'block';
                 isVoiceActive = true;
             } else if (state === 'connecting') {
                 statusText.textContent = '연결 중...';
                 sendButton.style.display = 'none';
             } else {
                 statusText.textContent = '연결 대기 중';
+                sendButton.style.display = 'block';  // Show send button even when disconnected for text chat
                 isVoiceActive = false;
             }
         }
                     webrtc_id: webrtc_id,
                     web_search_enabled: webSearchEnabled,
                     target_language: selectedLanguage,
+                    system_prompt: systemPrompt
                 });
                 const response = await fetch('/webrtc/offer', {
                         webrtc_id: webrtc_id,
                         web_search_enabled: webSearchEnabled,
                         target_language: selectedLanguage,
+                        system_prompt: systemPrompt
                     })
                 });
                 const serverResponse = await response.json();
                     const eventJson = JSON.parse(event.data);
                     let content = eventJson.content;
                     if (selectedLanguage && eventJson.language) {
                         content += ` <span class="language-info">[${eventJson.language}]</span>`;
                     }
                     addMessage("assistant", content);
                 });
             const messageDiv = document.createElement('div');
             messageDiv.classList.add('message', role);
             if (content.includes('<span')) {
                 messageDiv.innerHTML = content;
             } else {
             chatMessages.appendChild(messageDiv);
             chatMessages.scrollTop = chatMessages.scrollHeight;
         }
         function stop() {
+            console.log('[STOP] Stopping connection...');
+            // Cancel animation frame first
             if (animationFrame) {
                 cancelAnimationFrame(animationFrame);
+                animationFrame = null;
             }
+            // Close audio context
             if (audioContext) {
                 audioContext.close();
                 audioContext = null;
                 analyser = null;
                 audioSource = null;
             }
+            // Close data channel
+            if (dataChannel) {
+                dataChannel.close();
+                dataChannel = null;
+            }
+            // Close peer connection
             if (peerConnection) {
+                console.log('[STOP] Current connection state:', peerConnection.connectionState);
+                // Stop all transceivers
                 if (peerConnection.getTransceivers) {
                     peerConnection.getTransceivers().forEach(transceiver => {
                         if (transceiver.stop) {
                         }
                     });
                 }
+                // Stop all senders
                 if (peerConnection.getSenders) {
                     peerConnection.getSenders().forEach(sender => {
+                        if (sender.track) {
+                            sender.track.stop();
+                        }
+                    });
+                }
+                // Stop all receivers
+                if (peerConnection.getReceivers) {
+                    peerConnection.getReceivers().forEach(receiver => {
+                        if (receiver.track) {
+                            receiver.track.stop();
+                        }
                     });
                 }
+                // Close the connection
                 peerConnection.close();
+                // Clear the reference
+                peerConnection = null;
+                console.log('[STOP] Connection closed');
             }
+            // Reset audio level
             audioLevel = 0;
+            isVoiceActive = false;
+            // Update UI
+            updateButtonState();
+            // Clear any existing webrtc_id
+            if (webrtc_id) {
+                console.log('[STOP] Clearing webrtc_id:', webrtc_id);
+                webrtc_id = null;
+            }
         }
         startButton.addEventListener('click', () => {
             console.log('clicked');
             }
         });
+        // Initialize on page load
         window.addEventListener('DOMContentLoaded', () => {
             sendButton.style.display = 'block';
         });
     return chatbot
 async def process_text_chat(message: str, web_search_enabled: bool, target_language: str,
                           system_prompt: str) -> Dict[str, str]:
     """Process text chat using GPT-4o-mini model"""
 class OpenAIHandler(AsyncStreamHandler):
     def __init__(self, web_search_enabled: bool = False, target_language: str = "",
+                 system_prompt: str = "", webrtc_id: str = None) -> None:
         super().__init__(
             expected_layout="mono",
             output_sample_rate=SAMPLE_RATE,
         self.web_search_enabled = web_search_enabled
         self.target_language = target_language
         self.system_prompt = system_prompt
+        print(f"[INIT] Handler created with web_search={web_search_enabled}, "
+              f"target_language={target_language}")
     def copy(self):
         # Get the most recent settings
             if recent_ids:
                 recent_id = recent_ids[0]
                 settings = connection_settings[recent_id]
+                # Log the settings being copied
+                print(f"[COPY] Copying settings from {recent_id}:")
                 return OpenAIHandler(
                     web_search_enabled=settings.get('web_search_enabled', False),
                     target_language=settings.get('target_language', ''),
                     system_prompt=settings.get('system_prompt', ''),
+                    webrtc_id=recent_id
                 )
+        print(f"[COPY] No settings found, creating default handler")
+        return OpenAIHandler(web_search_enabled=False)
     async def search_web(self, query: str) -> str:
         """Perform web search and return formatted results"""
             )
             await self.connection.response.create()
     def get_translation_instructions(self):
         """Get instructions for translation based on target language"""
+        if not self.target_language:
             return ""
         language_name = SUPPORTED_LANGUAGES.get(self.target_language, self.target_language)
         )
     async def start_up(self):
+        """Connect to realtime API"""
         # First check if we have the most recent settings
+        if connection_settings and self.webrtc_id:
+            if self.webrtc_id in connection_settings:
+                settings = connection_settings[self.webrtc_id]
                 self.web_search_enabled = settings.get('web_search_enabled', False)
                 self.target_language = settings.get('target_language', '')
                 self.system_prompt = settings.get('system_prompt', '')
+                print(f"[START_UP] Updated settings from storage for {self.webrtc_id}")
+        print(f"[START_UP] Starting normal mode")
         self.client = openai.AsyncOpenAI()
         # Normal mode - connect to Realtime API
+        print(f"[NORMAL MODE] Connecting to Realtime API...")
         # Define the web search function
         tools = []
         base_instructions = self.system_prompt or "You are a helpful assistant."
                         ),
                     )
+                # Handle function calls
+                elif event.type == "response.function_call_arguments.start":
                     print(f"Function call started")
                     self.function_call_in_progress = True
                     self.current_function_args = ""
                     self.current_call_id = getattr(event, 'call_id', None)
+                elif event.type == "response.function_call_arguments.delta":
                     if self.function_call_in_progress:
                         self.current_function_args += event.delta
+                elif event.type == "response.function_call_arguments.done":
                     if self.function_call_in_progress:
                         print(f"Function call done, args: {self.current_function_args}")
                         try:
                             self.current_call_id = None
     async def receive(self, frame: tuple[int, np.ndarray]) -> None:
+        # Normal mode - use Realtime API
+        if not self.connection:
+            print(f"[RECEIVE] No connection in normal mode, skipping")
+            return
+        try:
             _, array = frame
             array = array.squeeze()
+            audio_message = base64.b64encode(array.tobytes()).decode("utf-8")
+            await self.connection.input_audio_buffer.append(audio=audio_message)
+        except Exception as e:
+            print(f"Error in receive: {e}")
     async def emit(self) -> tuple[int, np.ndarray] | AdditionalOutputs | None:
+        # Normal mode
+        item = await wait_for_item(self.output_queue)
+        # Check if it's a dict with text message
+        if isinstance(item, dict) and item.get('type') == 'text_message':
+            await self.process_text_message(item['content'])
+            return None
+        return item
     async def shutdown(self) -> None:
+        print(f"[SHUTDOWN] Called")
+        # Normal mode - close Realtime API connection
+        if self.connection:
+            await self.connection.close()
+            self.connection = None
+            print("[NORMAL MODE] Connection closed")
 # Create initial handler instance
+handler = OpenAIHandler(web_search_enabled=False)
 # Create components
 chatbot = gr.Chatbot(type="messages")
     web_search_enabled = body.get("web_search_enabled", False)
     target_language = body.get("target_language", "")
     system_prompt = body.get("system_prompt", "")
+    print(f"[OFFER] Received offer with webrtc_id: {webrtc_id}")
+    print(f"[OFFER] web_search_enabled: {web_search_enabled}")
+    print(f"[OFFER] target_language: {target_language}")
     # Store settings with timestamp
     if webrtc_id:
             'web_search_enabled': web_search_enabled,
             'target_language': target_language,
             'system_prompt': system_prompt,
             'timestamp': asyncio.get_event_loop().time()
         }
+        print(f"[OFFER] Stored settings for {webrtc_id}:")
+        print(f"[OFFER] {connection_settings[webrtc_id]}")
     # Remove our custom route temporarily
     custom_route = None
             break
     # Forward to stream's offer handler
+    print(f"[OFFER] Forwarding to stream.offer()")
     response = await stream.offer(body)
     # Re-add our custom route
     if custom_route:
         app.routes.insert(0, custom_route)
+    print(f"[OFFER] Response status: {response.get('status', 'unknown') if isinstance(response, dict) else 'OK'}")
     return response
                     yield f"event: search\ndata: {json.dumps(output.args[0])}\n\n"
                 # Regular transcript event with language info
                 elif isinstance(output.args[0], dict) and 'event' in output.args[0]:
+                    event_data = output.args[0]
+                    if 'event' in event_data and hasattr(event_data['event'], 'transcript'):
                         data = {
                             "role": "assistant",
+                            "content": event_data['event'].transcript,
+                            "language": event_data.get('language', '')
                         }
                         yield f"event: output\ndata: {json.dumps(data)}\n\n"