Update app.py

app.py

@@ -23,149 +23,16 @@ import gradio as gr
 import io
 from scipy import signal
 import wave
-from datetime import datetime
-import sqlite3
 import aiosqlite
 from langdetect import detect, LangDetectException
+from datetime import datetime
 import uuid
 
 load_dotenv()
 
 SAMPLE_RATE = 24000
-
-# Supported languages for OpenAI Realtime API
-SUPPORTED_LANGUAGES = {
-    "ko": "한국어 (Korean)",
-    "en": "English",
-    "es": "Español (Spanish)",
-    "fr": "Français (French)",
-    "de": "Deutsch (German)",
-    "it": "Italiano (Italian)",
-    "pt": "Português (Portuguese)",
-    "ru": "Русский (Russian)",
-    "ja": "日本語 (Japanese)",
-    "zh": "中文 (Chinese)",
-    "ar": "العربية (Arabic)",
-    "hi": "हिन्दी (Hindi)",
-    "nl": "Nederlands (Dutch)",
-    "pl": "Polski (Polish)",
-    "tr": "Türkçe (Turkish)",
-    "vi": "Tiếng Việt (Vietnamese)",
-    "th": "ไทย (Thai)",
-    "id": "Bahasa Indonesia",
-    "sv": "Svenska (Swedish)",
-    "da": "Dansk (Danish)",
-    "no": "Norsk (Norwegian)",
-    "fi": "Suomi (Finnish)",
-    "he": "עברית (Hebrew)",
-    "uk": "Українська (Ukrainian)",
-    "cs": "Čeština (Czech)",
-    "el": "Ελληνικά (Greek)",
-    "ro": "Română (Romanian)",
-    "hu": "Magyar (Hungarian)",
-    "ms": "Bahasa Melayu (Malay)"
-}
-
-# Database setup
 DB_PATH = "chat_history.db"
 
-async def init_db():
-    """Initialize the SQLite database"""
-    async with aiosqlite.connect(DB_PATH) as db:
-        await db.execute("""
-            CREATE TABLE IF NOT EXISTS conversations (
-                id TEXT PRIMARY KEY,
-                title TEXT NOT NULL,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-            )
-        """)
-        
-        await db.execute("""
-            CREATE TABLE IF NOT EXISTS messages (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                conversation_id TEXT NOT NULL,
-                role TEXT NOT NULL,
-                content TEXT NOT NULL,
-                language TEXT,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                FOREIGN KEY (conversation_id) REFERENCES conversations (id)
-            )
-        """)
-        
-        await db.commit()
-
-async def save_message(conversation_id: str, role: str, content: str, language: str = None):
-    """Save a message to the database"""
-    async with aiosqlite.connect(DB_PATH) as db:
-        # Check if conversation exists
-        cursor = await db.execute(
-            "SELECT id FROM conversations WHERE id = ?", 
-            (conversation_id,)
-        )
-        exists = await cursor.fetchone()
-        
-        if not exists:
-            # Create new conversation
-            title = content[:50] + "..." if len(content) > 50 else content
-            await db.execute(
-                "INSERT INTO conversations (id, title) VALUES (?, ?)",
-                (conversation_id, title)
-            )
-        else:
-            # Update conversation timestamp
-            await db.execute(
-                "UPDATE conversations SET updated_at = CURRENT_TIMESTAMP WHERE id = ?",
-                (conversation_id,)
-            )
-        
-        # Insert message
-        await db.execute(
-            "INSERT INTO messages (conversation_id, role, content, language) VALUES (?, ?, ?, ?)",
-            (conversation_id, role, content, language)
-        )
-        
-        await db.commit()
-
-async def get_conversations():
-    """Get all conversations"""
-    async with aiosqlite.connect(DB_PATH) as db:
-        db.row_factory = aiosqlite.Row
-        cursor = await db.execute(
-            "SELECT * FROM conversations ORDER BY updated_at DESC"
-        )
-        conversations = await cursor.fetchall()
-        return [dict(conv) for conv in conversations]
-
-async def get_conversation_messages(conversation_id: str):
-    """Get all messages for a conversation"""
-    async with aiosqlite.connect(DB_PATH) as db:
-        db.row_factory = aiosqlite.Row
-        cursor = await db.execute(
-            "SELECT * FROM messages WHERE conversation_id = ? ORDER BY created_at",
-            (conversation_id,)
-        )
-        messages = await cursor.fetchall()
-        return [dict(msg) for msg in messages]
-
-def detect_language(text: str) -> str:
-    """Detect the language of the input text"""
-    try:
-        lang = detect(text)
-        # Map detected language to our supported languages
-        if lang == 'ko':
-            return 'ko'
-        elif lang == 'en':
-            return 'en'
-        elif lang in SUPPORTED_LANGUAGES:
-            return lang
-        else:
-            # Default to Korean if unsupported language
-            return 'ko'
-    except LangDetectException:
-        # Default to Korean if detection fails
-        return 'ko'
-
 # HTML content embedded as a string
 HTML_CONTENT = """<!DOCTYPE html>
 <html lang="ko">
@@ -252,60 +119,6 @@ HTML_CONTENT = """<!DOCTYPE html>
             font-size: 32px;
             letter-spacing: 1px;
         }
-        /* History section */
-        .history-section {
-            background-color: var(--card-bg);
-            border-radius: 12px;
-            padding: 20px;
-            border: 1px solid var(--border-color);
-            overflow-y: auto;
-            flex-shrink: 0;
-            max-height: 300px;
-        }
-        .history-item {
-            padding: 10px;
-            margin-bottom: 8px;
-            background-color: var(--dark-bg);
-            border-radius: 6px;
-            cursor: pointer;
-            transition: all 0.2s;
-            display: flex;
-            justify-content: space-between;
-            align-items: center;
-        }
-        .history-item:hover {
-            background-color: var(--hover-color);
-            transform: translateX(5px);
-        }
-        .history-item-title {
-            font-size: 14px;
-            color: var(--text-color);
-            overflow: hidden;
-            text-overflow: ellipsis;
-            white-space: nowrap;
-            flex-grow: 1;
-        }
-        .history-item-date {
-            font-size: 12px;
-            color: #888;
-            margin-left: 10px;
-        }
-        .new-chat-button {
-            width: 100%;
-            background: linear-gradient(135deg, #2ecc71, #27ae60);
-            color: white;
-            border: none;
-            padding: 10px 20px;
-            font-size: 14px;
-            border-radius: 6px;
-            cursor: pointer;
-            margin-bottom: 10px;
-            transition: all 0.3s;
-        }
-        .new-chat-button:hover {
-            background: linear-gradient(135deg, #27ae60, #229954);
-            transform: translateY(-2px);
-        }
         /* Settings section */
         .settings-section {
             background-color: var(--card-bg);
@@ -358,21 +171,37 @@ HTML_CONTENT = """<!DOCTYPE html>
         .toggle-switch.active .toggle-slider {
             transform: translateX(24px);
         }
-        /* Select dropdown */
-        select {
+        /* History section */
+        .history-section {
             background-color: var(--card-bg);
-            color: var(--text-color);
+            border-radius: 12px;
+            padding: 20px;
             border: 1px solid var(--border-color);
-            padding: 8px 12px;
+            margin-top: 20px;
+            max-height: 300px;
+            overflow-y: auto;
+        }
+        .history-item {
+            padding: 10px;
+            margin-bottom: 10px;
+            background-color: var(--dark-bg);
             border-radius: 6px;
-            font-size: 14px;
             cursor: pointer;
-            min-width: 120px;
-            max-width: 200px;
+            transition: background-color 0.2s;
         }
-        select:focus {
-            outline: none;
-            border-color: var(--primary-color);
+        .history-item:hover {
+            background-color: var(--hover-color);
+        }
+        .history-date {
+            font-size: 12px;
+            color: #888;
+        }
+        .history-preview {
+            font-size: 14px;
+            margin-top: 5px;
+            overflow: hidden;
+            text-overflow: ellipsis;
+            white-space: nowrap;
         }
         /* Text inputs */
         .text-input-section {
@@ -677,12 +506,6 @@ HTML_CONTENT = """<!DOCTYPE html>
         
         <div class="main-content">
             <div class="sidebar">
-                <div class="history-section">
-                    <h3 style="margin: 0 0 15px 0; color: var(--primary-color);">대화 기록</h3>
-                    <button class="new-chat-button" onclick="startNewChat()">+ 새 대화</button>
-                    <div id="history-list"></div>
-                </div>
-                
                 <div class="settings-section">
                     <h3 style="margin: 0 0 15px 0; color: var(--primary-color);">설정</h3>
                     <div class="settings-grid">
@@ -692,54 +515,18 @@ HTML_CONTENT = """<!DOCTYPE html>
                                 <div class="toggle-slider"></div>
                             </div>
                         </div>
-                        <div class="setting-item">
-                            <span class="setting-label">자동 언어 감지</span>
-                            <div id="auto-lang-toggle" class="toggle-switch active">
-                                <div class="toggle-slider"></div>
-                            </div>
-                        </div>
-                        <div class="setting-item">
-                            <span class="setting-label">번역 언어</span>
-                            <select id="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="text-input-section">
                         <label for="system-prompt" class="setting-label">시스템 프롬프트:</label>
-                        <textarea id="system-prompt" placeholder="AI 어시스턴트의 성격, 역할, 행동 방식을 정의하세요...">당신은 친절하고 도움이 되는 AI 어시스턴트입니다. 사용자의 요청에 정확하고 유용한 답변을 제공합니다.</textarea>
+                        <textarea id="system-prompt" placeholder="AI 어시스턴트의 성격, 역할, 행동 방식을 정의하세요...">You are a helpful assistant. Respond in a friendly and professional manner.</textarea>
                     </div>
                 </div>
                 
+                <div class="history-section">
+                    <h3 style="margin: 0 0 15px 0; color: var(--primary-color);">대화 기록</h3>
+                    <div id="history-list"></div>
+                </div>
+                
                 <div class="controls">
                     <button id="start-button">대화 시작</button>
                 </div>
@@ -765,11 +552,8 @@ HTML_CONTENT = """<!DOCTYPE html>
         let peerConnection;
         let webrtc_id;
         let webSearchEnabled = false;
-        let autoLanguageDetection = true;
-        let selectedLanguage = "";
-        let systemPrompt = "당신은 친절하고 도움이 되는 AI 어시스턴트입니다. 사용자의 요청에 정확하고 유용한 답변을 제공합니다.";
-        let currentConversationId = null;
-        
+        let systemPrompt = "You are a helpful assistant. Respond in a friendly and professional manner.";
+        let currentSessionId = null;
         const audioOutput = document.getElementById('audio-output');
         const startButton = document.getElementById('start-button');
         const sendButton = document.getElementById('send-button');
@@ -777,63 +561,39 @@ HTML_CONTENT = """<!DOCTYPE html>
         const statusDot = document.getElementById('status-dot');
         const statusText = document.getElementById('status-text');
         const searchToggle = document.getElementById('search-toggle');
-        const autoLangToggle = document.getElementById('auto-lang-toggle');
-        const languageSelect = document.getElementById('language-select');
         const systemPromptInput = document.getElementById('system-prompt');
         const textInput = document.getElementById('text-input');
         const historyList = document.getElementById('history-list');
-        
         let audioLevel = 0;
         let animationFrame;
         let audioContext, analyser, audioSource;
         let dataChannel = null;
         let isVoiceActive = false;
         
-        // Initialize
-        window.addEventListener('DOMContentLoaded', async () => {
-            sendButton.style.display = 'block';
-            await loadHistory();
-            startNewChat();
-        });
-        
-        // Start new chat
-        function startNewChat() {
-            currentConversationId = generateUUID();
-            chatMessages.innerHTML = '';
-            console.log('Started new conversation:', currentConversationId);
-        }
-        
-        // Generate UUID
-        function generateUUID() {
-            return 'xxxx-xxxx-4xxx-yxxx-xxxx'.replace(/[xy]/g, function(c) {
-                const r = Math.random() * 16 | 0;
-                const v = c === 'x' ? r : (r & 0x3 | 0x8);
-                return v.toString(16);
-            });
+        // Start new session
+        async function startNewSession() {
+            const response = await fetch('/session/new', { method: 'POST' });
+            const data = await response.json();
+            currentSessionId = data.session_id;
+            console.log('New session started:', currentSessionId);
+            loadHistory();
         }
         
         // Load conversation history
         async function loadHistory() {
             try {
-                const response = await fetch('/conversations');
+                const response = await fetch('/history/recent');
                 const conversations = await response.json();
                 
                 historyList.innerHTML = '';
                 conversations.forEach(conv => {
                     const item = document.createElement('div');
                     item.className = 'history-item';
+                    item.innerHTML = `
+                        <div class="history-date">${new Date(conv.created_at).toLocaleString()}</div>
+                        <div class="history-preview">${conv.summary || '대화 시작'}</div>
+                    `;
                     item.onclick = () => loadConversation(conv.id);
-                    
-                    const title = document.createElement('div');
-                    title.className = 'history-item-title';
-                    title.textContent = conv.title;
-                    
-                    const date = document.createElement('div');
-                    date.className = 'history-item-date';
-                    date.textContent = new Date(conv.updated_at).toLocaleDateString('ko-KR');
-                    
-                    item.appendChild(title);
-                    item.appendChild(date);
                     historyList.appendChild(item);
                 });
             } catch (error) {
@@ -841,15 +601,13 @@ HTML_CONTENT = """<!DOCTYPE html>
             }
         }
         
-        // Load a specific conversation
-        async function loadConversation(conversationId) {
+        // Load specific conversation
+        async function loadConversation(sessionId) {
             try {
-                const response = await fetch(`/conversation/${conversationId}`);
+                const response = await fetch(`/history/${sessionId}`);
                 const messages = await response.json();
                 
-                currentConversationId = conversationId;
                 chatMessages.innerHTML = '';
-                
                 messages.forEach(msg => {
                     addMessage(msg.role, msg.content, false);
                 });
@@ -865,23 +623,9 @@ HTML_CONTENT = """<!DOCTYPE html>
             console.log('Web search enabled:', webSearchEnabled);
         });
         
-        // Auto language detection toggle
-        autoLangToggle.addEventListener('click', () => {
-            autoLanguageDetection = !autoLanguageDetection;
-            autoLangToggle.classList.toggle('active', autoLanguageDetection);
-            languageSelect.disabled = autoLanguageDetection;
-            console.log('Auto language detection:', autoLanguageDetection);
-        });
-        
-        // Language selection
-        languageSelect.addEventListener('change', () => {
-            selectedLanguage = languageSelect.value;
-            console.log('Selected language:', selectedLanguage);
-        });
-        
         // System prompt update
         systemPromptInput.addEventListener('input', () => {
-            systemPrompt = systemPromptInput.value || "당신은 친절하고 도움이 되는 AI 어시스턴트입니다.";
+            systemPrompt = systemPromptInput.value || "You are a helpful assistant. Respond in a friendly and professional manner.";
         });
         
         // Text input handling
@@ -899,7 +643,7 @@ HTML_CONTENT = """<!DOCTYPE html>
             if (!message) return;
             
             // Add user message to chat
-            addMessage('user', message, true);
+            addMessage('user', message);
             textInput.value = '';
             
             // Show sending indicator
@@ -918,10 +662,8 @@ HTML_CONTENT = """<!DOCTYPE html>
                     body: JSON.stringify({
                         message: message,
                         web_search_enabled: webSearchEnabled,
-                        target_language: autoLanguageDetection ? '' : selectedLanguage,
                         system_prompt: systemPrompt,
-                        conversation_id: currentConversationId,
-                        auto_detect: autoLanguageDetection
+                        session_id: currentSessionId
                     })
                 });
                 
@@ -936,13 +678,10 @@ HTML_CONTENT = """<!DOCTYPE html>
                 } else {
                     // Add assistant response
                     let content = data.response;
-                    if (data.language) {
-                        content += ` <span class="language-info">[${data.language}]</span>`;
+                    if (data.detected_language) {
+                        content += ` <span class="language-info">[${data.detected_language}]</span>`;
                     }
-                    addMessage('assistant', content, true);
-                    
-                    // Refresh history
-                    await loadHistory();
+                    addMessage('assistant', content);
                 }
             } catch (error) {
                 console.error('Error sending text message:', error);
@@ -963,11 +702,10 @@ HTML_CONTENT = """<!DOCTYPE html>
                 sendButton.style.display = 'none';
             } else {
                 statusText.textContent = '연결 대기 중';
-                sendButton.style.display = 'block';
+                sendButton.style.display = 'block';  // Show send button even when disconnected for text chat
                 isVoiceActive = false;
             }
         }
-        
         function updateButtonState() {
             const button = document.getElementById('start-button');
             if (peerConnection && (peerConnection.connectionState === 'connecting' || peerConnection.connectionState === 'new')) {
@@ -997,7 +735,6 @@ HTML_CONTENT = """<!DOCTYPE html>
                 updateStatus('disconnected');
             }
         }
-        
         function setupAudioVisualization(stream) {
             audioContext = new (window.AudioContext || window.webkitAudioContext)();
             analyser = audioContext.createAnalyser();
@@ -1032,7 +769,6 @@ HTML_CONTENT = """<!DOCTYPE html>
             
             updateAudioLevel();
         }
-        
         function showError(message) {
             const toast = document.getElementById('error-toast');
             toast.textContent = message;
@@ -1042,7 +778,6 @@ HTML_CONTENT = """<!DOCTYPE html>
                 toast.style.display = 'none';
             }, 5000);
         }
-        
         async function setupWebRTC() {
             const config = __RTC_CONFIGURATION__;
             peerConnection = new RTCPeerConnection(config);
@@ -1055,7 +790,6 @@ HTML_CONTENT = """<!DOCTYPE html>
                     toast.style.display = 'none';
                 }, 5000);
             }, 5000);
-            
             try {
                 const stream = await navigator.mediaDevices.getUserMedia({
                     audio: true
@@ -1098,7 +832,6 @@ HTML_CONTENT = """<!DOCTYPE html>
                         peerConnection.addEventListener("icegatheringstatechange", checkState);
                     }
                 });
-                
                 peerConnection.addEventListener('connectionstatechange', () => {
                     console.log('connectionstatechange', peerConnection.connectionState);
                     if (peerConnection.connectionState === 'connected') {
@@ -1108,9 +841,16 @@ HTML_CONTENT = """<!DOCTYPE html>
                     }
                     updateButtonState();
                 });
-                
                 webrtc_id = Math.random().toString(36).substring(7);
                 
+                // Log current settings before sending
+                console.log('Sending offer with settings:', {
+                    webrtc_id: webrtc_id,
+                    web_search_enabled: webSearchEnabled,
+                    system_prompt: systemPrompt,
+                    session_id: currentSessionId
+                });
+                
                 const response = await fetch('/webrtc/offer', {
                     method: 'POST',
                     headers: { 'Content-Type': 'application/json' },
@@ -1119,13 +859,10 @@ HTML_CONTENT = """<!DOCTYPE html>
                         type: peerConnection.localDescription.type,
                         webrtc_id: webrtc_id,
                         web_search_enabled: webSearchEnabled,
-                        target_language: autoLanguageDetection ? '' : selectedLanguage,
                         system_prompt: systemPrompt,
-                        conversation_id: currentConversationId,
-                        auto_detect: autoLanguageDetection
+                        session_id: currentSessionId
                     })
                 });
-                
                 const serverResponse = await response.json();
                 if (serverResponse.status === 'failed') {
                     showError(serverResponse.meta.error === 'concurrency_limit_reached'
@@ -1134,25 +871,21 @@ HTML_CONTENT = """<!DOCTYPE html>
                     stop();
                     return;
                 }
-                
                 await peerConnection.setRemoteDescription(serverResponse);
                 const eventSource = new EventSource('/outputs?webrtc_id=' + webrtc_id);
-                eventSource.addEventListener("output", async (event) => {
+                eventSource.addEventListener("output", (event) => {
                     const eventJson = JSON.parse(event.data);
                     let content = eventJson.content;
                     
-                    if (eventJson.language) {
-                        content += ` <span class="language-info">[${eventJson.language}]</span>`;
+                    if (eventJson.detected_language) {
+                        content += ` <span class="language-info">[${eventJson.detected_language}]</span>`;
                     }
-                    addMessage("assistant", content, true);
-                    
-                    // Refresh history after receiving a response
-                    await loadHistory();
+                    addMessage("assistant", content);
                 });
                 eventSource.addEventListener("search", (event) => {
                     const eventJson = JSON.parse(event.data);
                     if (eventJson.query) {
-                        addMessage("search-result", `웹 검색 중: "${eventJson.query}"`, true);
+                        addMessage("search-result", `웹 검색 중: "${eventJson.query}"`);
                     }
                 });
             } catch (err) {
@@ -1162,8 +895,7 @@ HTML_CONTENT = """<!DOCTYPE html>
                 stop();
             }
         }
-        
-        function addMessage(role, content, save = false) {
+        function addMessage(role, content, save = true) {
             const messageDiv = document.createElement('div');
             messageDiv.classList.add('message', role);
             
@@ -1175,16 +907,15 @@ HTML_CONTENT = """<!DOCTYPE html>
             chatMessages.appendChild(messageDiv);
             chatMessages.scrollTop = chatMessages.scrollHeight;
             
-            // Save to database if needed
-            if (save && currentConversationId && role !== 'search-result') {
-                fetch('/message', {
+            // Save message to database if save flag is true
+            if (save && currentSessionId) {
+                fetch('/message/save', {
                     method: 'POST',
                     headers: { 'Content-Type': 'application/json' },
                     body: JSON.stringify({
-                        conversation_id: currentConversationId,
+                        session_id: currentSessionId,
                         role: role,
-                        content: content.replace(/<[^>]*>/g, ''), // Remove HTML tags
-                        language: ''
+                        content: content
                     })
                 }).catch(error => console.error('Failed to save message:', error));
             }
@@ -1193,11 +924,13 @@ HTML_CONTENT = """<!DOCTYPE html>
         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;
@@ -1205,14 +938,17 @@ HTML_CONTENT = """<!DOCTYPE html>
                 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) {
@@ -1221,6 +957,7 @@ HTML_CONTENT = """<!DOCTYPE html>
                     });
                 }
                 
+                // Stop all senders
                 if (peerConnection.getSenders) {
                     peerConnection.getSenders().forEach(sender => {
                         if (sender.track) {
@@ -1229,6 +966,7 @@ HTML_CONTENT = """<!DOCTYPE html>
                     });
                 }
                 
+                // Stop all receivers
                 if (peerConnection.getReceivers) {
                     peerConnection.getReceivers().forEach(receiver => {
                         if (receiver.track) {
@@ -1237,22 +975,28 @@ HTML_CONTENT = """<!DOCTYPE html>
                     });
                 }
                 
+                // 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');
             console.log(peerConnection, peerConnection?.connectionState);
@@ -1263,6 +1007,13 @@ HTML_CONTENT = """<!DOCTYPE html>
                 stop();
             }
         });
+        
+        // Initialize on page load
+        window.addEventListener('DOMContentLoaded', () => {
+            sendButton.style.display = 'block';
+            startNewSession();
+            loadHistory();
+        });
     </script>
 </body>
 
@@ -1310,9 +1061,135 @@ class BraveSearchClient:
                 return []
 
 
+# Database helper class
+class ChatDatabase:
+    """Database manager for chat history"""
+    
+    @staticmethod
+    async def init():
+        """Initialize database tables"""
+        async with aiosqlite.connect(DB_PATH) as db:
+            await db.execute("""
+                CREATE TABLE IF NOT EXISTS conversations (
+                    id TEXT PRIMARY KEY,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    summary TEXT
+                )
+            """)
+            
+            await db.execute("""
+                CREATE TABLE IF NOT EXISTS messages (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    session_id TEXT NOT NULL,
+                    role TEXT NOT NULL,
+                    content TEXT NOT NULL,
+                    detected_language TEXT,
+                    timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    FOREIGN KEY (session_id) REFERENCES conversations(id)
+                )
+            """)
+            
+            await db.commit()
+    
+    @staticmethod
+    async def create_session(session_id: str):
+        """Create a new conversation session"""
+        async with aiosqlite.connect(DB_PATH) as db:
+            await db.execute(
+                "INSERT INTO conversations (id) VALUES (?)",
+                (session_id,)
+            )
+            await db.commit()
+    
+    @staticmethod
+    async def save_message(session_id: str, role: str, content: str):
+        """Save a message to the database"""
+        # Detect language
+        detected_language = None
+        try:
+            if content and len(content) > 10:  # Only detect for substantial content
+                detected_language = detect(content)
+        except LangDetectException:
+            pass
+        
+        async with aiosqlite.connect(DB_PATH) as db:
+            await db.execute(
+                """INSERT INTO messages (session_id, role, content, detected_language) 
+                   VALUES (?, ?, ?, ?)""",
+                (session_id, role, content, detected_language)
+            )
+            
+            # Update conversation's updated_at timestamp
+            await db.execute(
+                "UPDATE conversations SET updated_at = CURRENT_TIMESTAMP WHERE id = ?",
+                (session_id,)
+            )
+            
+            # Update conversation summary (use first user message as summary)
+            if role == "user":
+                cursor = await db.execute(
+                    "SELECT summary FROM conversations WHERE id = ?",
+                    (session_id,)
+                )
+                row = await cursor.fetchone()
+                if row and not row[0]:  # If no summary exists
+                    summary = content[:100] + "..." if len(content) > 100 else content
+                    await db.execute(
+                        "UPDATE conversations SET summary = ? WHERE id = ?",
+                        (summary, session_id)
+                    )
+            
+            await db.commit()
+    
+    @staticmethod
+    async def get_recent_conversations(limit: int = 10):
+        """Get recent conversations"""
+        async with aiosqlite.connect(DB_PATH) as db:
+            cursor = await db.execute(
+                """SELECT id, created_at, summary 
+                   FROM conversations 
+                   ORDER BY updated_at DESC 
+                   LIMIT ?""",
+                (limit,)
+            )
+            rows = await cursor.fetchall()
+            return [
+                {
+                    "id": row[0],
+                    "created_at": row[1],
+                    "summary": row[2] or "새 대화"
+                }
+                for row in rows
+            ]
+    
+    @staticmethod
+    async def get_conversation_messages(session_id: str):
+        """Get all messages for a conversation"""
+        async with aiosqlite.connect(DB_PATH) as db:
+            cursor = await db.execute(
+                """SELECT role, content, detected_language, timestamp 
+                   FROM messages 
+                   WHERE session_id = ? 
+                   ORDER BY timestamp ASC""",
+                (session_id,)
+            )
+            rows = await cursor.fetchall()
+            return [
+                {
+                    "role": row[0],
+                    "content": row[1],
+                    "detected_language": row[2],
+                    "timestamp": row[3]
+                }
+                for row in rows
+            ]
+
+
 # Initialize search client globally
 brave_api_key = os.getenv("BSEARCH_API")
 search_client = BraveSearchClient(brave_api_key) if brave_api_key else None
+print(f"Search client initialized: {search_client is not None}, API key present: {bool(brave_api_key)}")
 
 # Store connection settings
 connection_settings = {}
@@ -1320,49 +1197,22 @@ connection_settings = {}
 # Initialize OpenAI client for text chat
 client = openai.AsyncOpenAI()
 
-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}."
-    )
 
 def update_chatbot(chatbot: list[dict], response: ResponseAudioTranscriptDoneEvent):
     chatbot.append({"role": "assistant", "content": response.transcript})
     return chatbot
 
 
-async def process_text_chat(message: str, web_search_enabled: bool, target_language: str, 
-                          system_prompt: str, conversation_id: str, auto_detect: bool) -> Dict[str, str]:
+async def process_text_chat(message: str, web_search_enabled: bool, system_prompt: str, session_id: str) -> Dict[str, str]:
     """Process text chat using GPT-4o-mini model"""
     try:
-        # Auto-detect language if enabled
-        if auto_detect:
-            detected_lang = detect_language(message)
-            if detected_lang in ['en', 'ko']:
-                target_language = detected_lang
-            else:
-                target_language = 'ko'  # Default to Korean
-        
-        # Save user message
-        await save_message(conversation_id, "user", message, target_language)
-        
-        # Prepare system prompt based on language
-        if target_language == 'en':
-            base_instructions = f"You are a helpful assistant. {system_prompt}"
-        else:
-            base_instructions = system_prompt or "당신은 친절하고 도움이 되는 AI 어시스턴트입니다."
-        
         messages = [
-            {"role": "system", "content": base_instructions}
+            {"role": "system", "content": system_prompt or "You are a helpful assistant."}
         ]
         
         # Handle web search if enabled
         if web_search_enabled and search_client:
+            # Check if the message requires web search
             search_keywords = ["날씨", "기온", "비", "눈", "뉴스", "소식", "현재", "최근", 
                              "오늘", "지금", "가격", "환율", "주가", "weather", "news", 
                              "current", "today", "price", "2024", "2025"]
@@ -1370,6 +1220,7 @@ async def process_text_chat(message: str, web_search_enabled: bool, target_langu
             should_search = any(keyword in message.lower() for keyword in search_keywords)
             
             if should_search:
+                # Perform web search
                 search_results = await search_client.search(message)
                 if search_results:
                     search_context = "웹 검색 결과:\n\n"
@@ -1378,7 +1229,7 @@ async def process_text_chat(message: str, web_search_enabled: bool, target_langu
                     
                     messages.append({
                         "role": "system", 
-                        "content": "다음 웹 검색 결과를 참고하여 답변하세요: \n\n" + search_context
+                        "content": "다음 웹 검색 결과를 참고하여 답변하세요:\n\n" + search_context
                     })
         
         messages.append({"role": "user", "content": message})
@@ -1393,12 +1244,22 @@ async def process_text_chat(message: str, web_search_enabled: bool, target_langu
         
         response_text = response.choices[0].message.content
         
-        # Save assistant response
-        await save_message(conversation_id, "assistant", response_text, target_language)
+        # Detect language
+        detected_language = None
+        try:
+            if response_text and len(response_text) > 10:
+                detected_language = detect(response_text)
+        except:
+            pass
+        
+        # Save messages to database
+        if session_id:
+            await ChatDatabase.save_message(session_id, "user", message)
+            await ChatDatabase.save_message(session_id, "assistant", response_text)
         
         return {
             "response": response_text,
-            "language": SUPPORTED_LANGUAGES.get(target_language, "") if target_language else ""
+            "detected_language": detected_language
         }
         
     except Exception as e:
@@ -1407,9 +1268,8 @@ 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, conversation_id: str = None,
-                 auto_detect: bool = True) -> None:
+    def __init__(self, web_search_enabled: bool = False, system_prompt: str = "", 
+                 webrtc_id: str = None, session_id: str = None) -> None:
         super().__init__(
             expected_layout="mono",
             output_sample_rate=SAMPLE_RATE,
@@ -1424,13 +1284,15 @@ class OpenAIHandler(AsyncStreamHandler):
         self.current_call_id = None
         self.webrtc_id = webrtc_id
         self.web_search_enabled = web_search_enabled
-        self.target_language = target_language
         self.system_prompt = system_prompt
-        self.conversation_id = conversation_id
-        self.auto_detect = auto_detect
+        self.session_id = session_id
+        
+        print(f"[INIT] Handler created with web_search={web_search_enabled}, session_id={session_id}")
 
     def copy(self):
+        # Get the most recent settings
         if connection_settings:
+            # Get the most recent webrtc_id
             recent_ids = sorted(connection_settings.keys(), 
                               key=lambda k: connection_settings[k].get('timestamp', 0), 
                               reverse=True)
@@ -1438,15 +1300,17 @@ class OpenAIHandler(AsyncStreamHandler):
                 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,
-                    conversation_id=settings.get('conversation_id'),
-                    auto_detect=settings.get('auto_detect', True)
+                    session_id=settings.get('session_id')
                 )
         
+        print(f"[COPY] No settings found, creating default handler")
         return OpenAIHandler(web_search_enabled=False)
 
     async def search_web(self, query: str) -> str:
@@ -1459,6 +1323,7 @@ class OpenAIHandler(AsyncStreamHandler):
         if not results:
             return f"'{query}'에 대한 검색 결과를 찾을 수 없습니다."
         
+        # Format search results
         formatted_results = []
         for i, result in enumerate(results, 1):
             formatted_results.append(
@@ -1483,26 +1348,31 @@ class OpenAIHandler(AsyncStreamHandler):
 
     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', '')
-                self.conversation_id = settings.get('conversation_id')
-                self.auto_detect = settings.get('auto_detect', True)
+                self.session_id = settings.get('session_id')
+                
+                print(f"[START_UP] Updated settings from storage for {self.webrtc_id}")
         
         self.client = openai.AsyncOpenAI()
         
+        # Connect to Realtime API
+        print(f"[REALTIME API] Connecting...")
+        
+        # Define the web search function
         tools = []
-        base_instructions = self.system_prompt or "당신은 친절하고 도움이 되는 AI 어시스턴트입니다."
+        base_instructions = self.system_prompt or "You are a helpful assistant."
         
         if self.web_search_enabled and self.search_client:
             tools = [{
                 "type": "function",
                 "function": {
                     "name": "web_search",
-                    "description": "Search the web for current information.",
+                    "description": "Search the web for current information. Use this for weather, news, prices, current events, or any time-sensitive topics.",
                     "parameters": {
                         "type": "object",
                         "properties": {
@@ -1515,33 +1385,68 @@ class OpenAIHandler(AsyncStreamHandler):
                     }
                 }
             }]
+            print("Web search function added to tools")
+            
+            search_instructions = (
+                "\n\nYou have web search capabilities. "
+                "IMPORTANT: You MUST use the web_search function for ANY of these topics:\n"
+                "- Weather (날씨, 기온, 비, 눈)\n"
+                "- News (뉴스, 소식)\n"
+                "- Current events (현재, 최근, 오늘, 지금)\n"
+                "- Prices (가격, 환율, 주가)\n"
+                "- Sports scores or results\n"
+                "- Any question about 2024 or 2025\n"
+                "- Any time-sensitive information\n\n"
+                "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 + search_instructions
+        else:
+            instructions = base_instructions
         
         async with self.client.beta.realtime.connect(
             model="gpt-4o-mini-realtime-preview-2024-12-17"
         ) as conn:
+            # Update session with tools
             session_update = {
                 "turn_detection": {"type": "server_vad"},
-                "instructions": base_instructions,
+                "instructions": instructions,
                 "tools": tools,
                 "tool_choice": "auto" if tools else "none",
                 "temperature": 0.7,
                 "max_response_output_tokens": 4096,
                 "modalities": ["text", "audio"],
-                "voice": "nova"
+                "voice": "alloy"
             }
             
             await conn.session.update(session=session_update)
             self.connection = conn
+            print(f"Connected with tools: {len(tools)} functions")
             
             async for event in self.connection:
+                # Debug logging for function calls
+                if event.type.startswith("response.function_call"):
+                    print(f"Function event: {event.type}")
+                
                 if event.type == "response.audio_transcript.done":
-                    # Save the transcript
-                    if self.conversation_id:
-                        await save_message(self.conversation_id, "assistant", event.transcript)
+                    print(f"[RESPONSE] Transcript: {event.transcript[:100]}...")
+                    
+                    # Detect language
+                    detected_language = None
+                    try:
+                        if event.transcript and len(event.transcript) > 10:
+                            detected_language = detect(event.transcript)
+                    except:
+                        pass
+                    
+                    # Save to database
+                    if self.session_id:
+                        await ChatDatabase.save_message(self.session_id, "assistant", event.transcript)
                     
                     output_data = {
                         "event": event,
-                        "language": SUPPORTED_LANGUAGES.get(self.target_language, "") if self.target_language else ""
+                        "detected_language": detected_language
                     }
                     await self.output_queue.put(AdditionalOutputs(output_data))
                 
@@ -1557,6 +1462,7 @@ class OpenAIHandler(AsyncStreamHandler):
                 
                 # 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)
@@ -1567,17 +1473,22 @@ class OpenAIHandler(AsyncStreamHandler):
                 
                 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:
                             args = json.loads(self.current_function_args)
                             query = args.get("query", "")
                             
+                            # Emit search event to client
                             await self.output_queue.put(AdditionalOutputs({
                                 "type": "search",
                                 "query": query
                             }))
                             
+                            # Perform the search
                             search_results = await self.search_web(query)
+                            print(f"Search results length: {len(search_results)}")
                             
+                            # Send function result back to the model
                             if self.connection and self.current_call_id:
                                 await self.connection.conversation.item.create(
                                     item={
@@ -1597,6 +1508,7 @@ class OpenAIHandler(AsyncStreamHandler):
 
     async def receive(self, frame: tuple[int, np.ndarray]) -> None:
         if not self.connection:
+            print(f"[RECEIVE] No connection, skipping")
             return
         try:
             _, array = frame
@@ -1609,6 +1521,7 @@ class OpenAIHandler(AsyncStreamHandler):
     async def emit(self) -> tuple[int, np.ndarray] | AdditionalOutputs | None:
         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
@@ -1616,9 +1529,12 @@ class OpenAIHandler(AsyncStreamHandler):
         return item
 
     async def shutdown(self) -> None:
+        print(f"[SHUTDOWN] Called")
+        
         if self.connection:
             await self.connection.close()
             self.connection = None
+            print("[REALTIME API] Connection closed")
 
 
 # Create initial handler instance
@@ -1629,7 +1545,7 @@ chatbot = gr.Chatbot(type="messages")
 
 # Create stream with handler instance
 stream = Stream(
-    handler,
+    handler,  # Pass instance, not factory
     mode="send-receive",
     modality="audio",
     additional_inputs=[chatbot],
@@ -1642,13 +1558,14 @@ stream = Stream(
 
 app = FastAPI()
 
+# Mount stream
+stream.mount(app)
+
 # Initialize database on startup
 @app.on_event("startup")
 async def startup_event():
-    await init_db()
-
-# Mount stream
-stream.mount(app)
+    await ChatDatabase.init()
+    print("Database initialized")
 
 # Intercept offer to capture settings
 @app.post("/webrtc/offer", include_in_schema=False)
@@ -1658,20 +1575,24 @@ async def custom_offer(request: Request):
     
     webrtc_id = body.get("webrtc_id")
     web_search_enabled = body.get("web_search_enabled", False)
-    target_language = body.get("target_language", "")
     system_prompt = body.get("system_prompt", "")
-    conversation_id = body.get("conversation_id")
-    auto_detect = body.get("auto_detect", True)
+    session_id = body.get("session_id")
+    
+    print(f"[OFFER] Received offer with webrtc_id: {webrtc_id}")
+    print(f"[OFFER] web_search_enabled: {web_search_enabled}")
+    print(f"[OFFER] session_id: {session_id}")
     
+    # Store settings with timestamp
     if webrtc_id:
         connection_settings[webrtc_id] = {
             'web_search_enabled': web_search_enabled,
-            'target_language': target_language,
             'system_prompt': system_prompt,
-            'conversation_id': conversation_id,
-            'auto_detect': auto_detect,
+            'session_id': session_id,
             '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
@@ -1680,14 +1601,56 @@ async def custom_offer(request: Request):
             custom_route = app.routes.pop(i)
             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
 
 
+@app.post("/session/new")
+async def create_new_session():
+    """Create a new chat session"""
+    session_id = str(uuid.uuid4())
+    await ChatDatabase.create_session(session_id)
+    return {"session_id": session_id}
+
+
+@app.post("/message/save")
+async def save_message(request: Request):
+    """Save a message to the database"""
+    body = await request.json()
+    session_id = body.get("session_id")
+    role = body.get("role")
+    content = body.get("content")
+    
+    if not all([session_id, role, content]):
+        return {"error": "Missing required fields"}
+    
+    await ChatDatabase.save_message(session_id, role, content)
+    return {"status": "ok"}
+
+
+@app.get("/history/recent")
+async def get_recent_history():
+    """Get recent conversation history"""
+    conversations = await ChatDatabase.get_recent_conversations()
+    return conversations
+
+
+@app.get("/history/{session_id}")
+async def get_conversation(session_id: str):
+    """Get messages for a specific conversation"""
+    messages = await ChatDatabase.get_conversation_messages(session_id)
+    return messages
+
+
 @app.post("/chat/text")
 async def chat_text(request: Request):
     """Handle text chat messages using GPT-4o-mini"""
@@ -1695,16 +1658,14 @@ async def chat_text(request: Request):
         body = await request.json()
         message = body.get("message", "")
         web_search_enabled = body.get("web_search_enabled", False)
-        target_language = body.get("target_language", "")
         system_prompt = body.get("system_prompt", "")
-        conversation_id = body.get("conversation_id")
-        auto_detect = body.get("auto_detect", True)
+        session_id = body.get("session_id")
         
         if not message:
             return {"error": "메시지가 비어있습니다."}
         
-        result = await process_text_chat(message, web_search_enabled, target_language, 
-                                       system_prompt, conversation_id, auto_detect)
+        # Process text chat
+        result = await process_text_chat(message, web_search_enabled, system_prompt, session_id)
         
         return result
         
@@ -1713,41 +1674,16 @@ async def chat_text(request: Request):
         return {"error": "채팅 처리 중 오류가 발생했습니다."}
 
 
-@app.get("/conversations")
-async def get_conversations_endpoint():
-    """Get all conversations"""
-    conversations = await get_conversations()
-    return conversations
-
-
-@app.get("/conversation/{conversation_id}")
-async def get_conversation_endpoint(conversation_id: str):
-    """Get messages for a specific conversation"""
-    messages = await get_conversation_messages(conversation_id)
-    return messages
-
-
-@app.post("/message")
-async def save_message_endpoint(request: Request):
-    """Save a message"""
-    body = await request.json()
-    await save_message(
-        body["conversation_id"],
-        body["role"],
-        body["content"],
-        body.get("language")
-    )
-    return {"status": "ok"}
-
-
 @app.post("/text_message/{webrtc_id}")
 async def receive_text_message(webrtc_id: str, request: Request):
     """Receive text message from client"""
     body = await request.json()
     message = body.get("content", "")
     
+    # Find the handler for this connection
     if webrtc_id in stream.handlers:
         handler = stream.handlers[webrtc_id]
+        # Queue the text message for processing
         await handler.output_queue.put({
             'type': 'text_message',
             'content': message
@@ -1762,15 +1698,17 @@ async def outputs(webrtc_id: str):
     async def output_stream():
         async for output in stream.output_stream(webrtc_id):
             if hasattr(output, 'args') and output.args:
+                # Check if it's a search event
                 if isinstance(output.args[0], dict) and output.args[0].get('type') == 'search':
                     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', '')
+                            "detected_language": event_data.get('detected_language')
                         }
                         yield f"event: output\ndata: {json.dumps(data)}\n\n"