Upload app.py

app.py

@@ -0,0 +1,784 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+import sys
+import io
+import os
+import locale
+
+# Comprehensive UTF-8 encoding setup for Windows
+if sys.platform.startswith('win'):
+    try:
+        # Set locale to UTF-8
+        try:
+            locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')
+        except:
+            try:
+                locale.setlocale(locale.LC_ALL, 'C.UTF-8')
+            except:
+                pass
+        
+        # Set console to UTF-8 mode
+        os.system('chcp 65001 > nul 2>&1')
+        
+        # Set environment variables for UTF-8
+        os.environ['PYTHONIOENCODING'] = 'utf-8:replace'
+        os.environ['PYTHONUTF8'] = '1'
+        
+        # Force UTF-8 encoding for stdout/stderr with error handling
+        try:
+            if hasattr(sys.stdout, 'reconfigure'):
+                sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+                sys.stderr.reconfigure(encoding='utf-8', errors='replace')
+            else:
+                # Fallback for older Python versions
+                sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8', errors='replace')
+                sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding='utf-8', errors='replace')
+        except Exception:
+            # Final fallback
+            sys.stdout = io.TextIOWrapper(sys.stdout.detach(), encoding='utf-8', errors='replace')
+            sys.stderr = io.TextIOWrapper(sys.stderr.detach(), encoding='utf-8', errors='replace')
+        
+    except Exception as e:
+        # Silently continue if encoding setup fails
+        pass
+
+# Store original print function before any imports
+import builtins
+_original_print = builtins.print
+
+def safe_print(*args, **kwargs):
+    """Safe print function that handles UTF-8 encoding"""
+    try:
+        # Convert all arguments to strings first to avoid encoding issues
+        safe_args = []
+        for arg in args:
+            if isinstance(arg, str):
+                # Ensure string can be encoded/decoded properly
+                try:
+                    arg.encode('utf-8')
+                    safe_args.append(arg)
+                except UnicodeEncodeError:
+                    safe_args.append(arg.encode('utf-8', errors='replace').decode('utf-8'))
+            else:
+                safe_args.append(str(arg))
+        
+        _original_print(*safe_args, **kwargs)
+    except (UnicodeEncodeError, UnicodeDecodeError) as e:
+        # Last resort: convert to ASCII with replacement
+        ascii_args = []
+        for arg in args:
+            if isinstance(arg, str):
+                ascii_args.append(arg.encode('ascii', errors='replace').decode('ascii'))
+            else:
+                ascii_args.append(str(arg).encode('ascii', errors='replace').decode('ascii'))
+        _original_print(*ascii_args, **kwargs)
+    except Exception:
+        # Ultimate fallback
+        _original_print("[Encoding Error in Print]")
+
+# Override built-in print
+builtins.print = safe_print
+"""
+Live Translation AI Agent - Two Person Mode
+Real-time Cross-Translation between Person A & Person B
+"""
+
+import gradio as gr
+import numpy as np
+import librosa
+import soundfile as sf
+import tempfile
+import os
+import time
+import logging
+import json
+from typing import Optional, Tuple, Dict, List
+import asyncio
+import threading
+from pathlib import Path
+
+# Load environment variables from .env file
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+    print("Environment variables loaded from .env file")
+except ImportError:
+    print("python-dotenv not available, using system environment variables")
+
+# OpenAI integration
+try:
+    import openai
+    OPENAI_AVAILABLE = True
+    print("OpenAI library loaded successfully")
+except ImportError:
+    OPENAI_AVAILABLE = False
+    print("OpenAI library not available")
+
+# Edge TTS for speech synthesis
+try:
+    import edge_tts
+    EDGE_TTS_AVAILABLE = True
+    print("Edge TTS loaded successfully")
+except ImportError:
+    EDGE_TTS_AVAILABLE = False
+    print("Edge TTS not available")
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class TranslationAIAgent:
+    """Main AI Agent for translation tasks - OpenAI Powered"""
+    
+    def __init__(self):
+        # Enhanced language and voice options with country flags
+        self.language_voice_options = {
+            'en': {
+                'name': 'English',
+                'options': [
+                    {'code': 'en-us', 'display': 'English (United States)', 'voice': 'en-US-JennyNeural', 'alt_voice': 'en-US-GuyNeural'},
+                    {'code': 'en-gb', 'display': 'English (United Kingdom)', 'voice': 'en-GB-LibbyNeural', 'alt_voice': 'en-GB-RyanNeural'},
+                ]
+            },
+            'es': {
+                'name': 'Spanish',
+                'options': [
+                    {'code': 'es-es', 'display': 'Spanish (Spain)', 'voice': 'es-ES-ElviraNeural', 'alt_voice': 'es-ES-AlvaroNeural'},
+                    {'code': 'es-mx', 'display': 'Spanish (Mexico)', 'voice': 'es-MX-DaliaNeural', 'alt_voice': 'es-MX-JorgeNeural'},
+                ]
+            },
+            'fr': {
+                'name': 'French',
+                'options': [
+                    {'code': 'fr-fr', 'display': 'French (France)', 'voice': 'fr-FR-DeniseNeural', 'alt_voice': 'fr-FR-HenriNeural'},
+                    {'code': 'fr-ca', 'display': 'French (Canada)', 'voice': 'fr-CA-SylvieNeural', 'alt_voice': 'fr-CA-AntoineNeural'},
+                ]
+            },
+            'de': {
+                'name': 'German',
+                'options': [
+                    {'code': 'de-de', 'display': 'German (Germany)', 'voice': 'de-DE-KatjaNeural', 'alt_voice': 'de-DE-ConradNeural'},
+                ]
+            },
+            'vi': {
+                'name': 'Vietnamese',
+                'options': [
+                    {'code': 'vi-vn', 'display': 'Vietnamese (Vietnam)', 'voice': 'vi-VN-HoaiMyNeural', 'alt_voice': 'vi-VN-NamMinhNeural'}
+                ]
+            },
+            'ja': {
+                'name': 'Japanese',
+                'options': [
+                    {'code': 'ja-jp', 'display': 'Japanese (Japan)', 'voice': 'ja-JP-NanamiNeural', 'alt_voice': 'ja-JP-KeitaNeural'}
+                ]
+            },
+            'zh': {
+                'name': 'Chinese',
+                'options': [
+                    {'code': 'zh-cn', 'display': 'Chinese (Simplified)', 'voice': 'zh-CN-XiaoxiaoNeural', 'alt_voice': 'zh-CN-YunxiNeural'},
+                ]
+            }
+        }
+        
+        # Create simple supported languages mapping for backward compatibility
+        self.supported_languages = {
+            lang_code: lang_info['name'] 
+            for lang_code, lang_info in self.language_voice_options.items()
+        }
+        
+        # Create default voice mapping for backward compatibility
+        self.voice_map = {
+            lang_code: lang_info['options'][0]['voice']
+            for lang_code, lang_info in self.language_voice_options.items()
+        }
+        
+        self.setup_openai_client()
+    
+    def setup_openai_client(self):
+        """Setup OpenAI client for translation and transcription"""
+        try:
+            if not OPENAI_AVAILABLE:
+                logger.error("OpenAI library not available - please install: pip install openai")
+                self.openai_client = None
+                self.openai_configured = False
+                return
+            
+            # Get OpenAI API key from environment
+            api_key = (
+                os.environ.get("OPENAI_API_KEY") or 
+                os.environ.get("OPENAI_KEY") or
+                os.getenv("OPENAI_API_KEY")
+            )
+            
+            if api_key and api_key.strip() and not api_key.strip().startswith("your-"):
+                self.openai_client = openai.OpenAI(api_key=api_key.strip())
+                self.openai_configured = True
+                logger.info("[SUCCESS] OpenAI client configured successfully - Real translation mode enabled")
+            else:
+                self.openai_client = None
+                self.openai_configured = False
+                logger.error("❌ OpenAI API key not found or invalid in environment variables")
+                logger.error("Please set OPENAI_API_KEY in your .env file with a valid API key")
+                
+        except Exception as e:
+            logger.error(f"OpenAI setup failed: {e}")
+            self.openai_client = None
+            self.openai_configured = False
+
+    def speech_to_text(self, audio_path: str, language: str = 'auto') -> tuple[str, str]:
+        """Convert speech to text using OpenAI Whisper API with language detection"""
+        try:
+            if not self.openai_configured:
+                raise Exception("OpenAI client not configured. Please check your API key.")
+            
+            if not os.path.exists(audio_path):
+                raise Exception(f"Audio file not found: {audio_path}")
+                
+            with open(audio_path, "rb") as audio_file:
+                # Use verbose_json to get language detection
+                transcript = self.openai_client.audio.transcriptions.create(
+                    model="whisper-1",
+                    file=audio_file,
+                    response_format="verbose_json",
+                    language=None  # Auto-detect language
+                )
+            
+            text = transcript.text.strip()
+            detected_language = transcript.language
+            
+            # Map language code to display name
+            language_names = {
+                'en': 'English',
+                'vi': 'Vietnamese',
+                'es': 'Spanish',
+                'fr': 'French',
+                'de': 'German',
+                'it': 'Italian',
+                'pt': 'Portuguese',
+                'ru': 'Russian',
+                'ja': 'Japanese',
+                'ko': 'Korean',
+                'zh': 'Chinese',
+                'ar': 'Arabic',
+                'hi': 'Hindi',
+                'th': 'Thai',
+                'tr': 'Turkish'
+            }
+            
+            detected_language_name = language_names.get(detected_language, detected_language)
+            
+            if text and len(text) > 2:
+                logger.info(f"OpenAI Whisper transcription: {text[:100]}...")
+                logger.info(f"Detected Language: {detected_language_name} ({detected_language})")
+                return text, detected_language_name
+            else:
+                return "No speech detected in audio file", "unknown"
+                
+        except Exception as e:
+            error_msg = str(e)
+            logger.error(f"Speech recognition error: {error_msg}")
+            
+            # Check for quota exceeded error
+            if "429" in error_msg or "quota" in error_msg.lower() or "insufficient_quota" in error_msg.lower():
+                logger.warning("[WARNING] OpenAI API quota exceeded - using fallback mode")
+                duration = self.get_audio_duration(audio_path)
+                return f"[API Quota Exceeded] Please add credits to your OpenAI account. Audio duration: {duration:.1f}s", "English"
+            
+            raise Exception(f"Speech recognition failed: {error_msg}")
+    
+    def get_audio_duration(self, audio_path: str) -> float:
+        """Get duration of audio file"""
+        try:
+            y, sr = librosa.load(audio_path)
+            return len(y) / sr
+        except:
+            return 0.0
+
+    def translate_text(self, text: str, source_lang: str, target_lang: str) -> str:
+        """Translate text using OpenAI GPT-4o Mini"""
+        try:
+            if not self.openai_configured:
+                raise Exception("OpenAI client not configured. Please check your API key.")
+            
+            # Create translation prompt
+            source_name = self.supported_languages.get(source_lang, source_lang)
+            target_name = self.supported_languages.get(target_lang, target_lang)
+            
+            prompt = f"""Translate the following {source_name} text to {target_name}. Provide only the translation, no explanations:
+
+{text}"""
+            
+            response = self.openai_client.chat.completions.create(
+                model="gpt-4o-mini",  # Using latest GPT-4o-mini model
+                messages=[{"role": "user", "content": prompt}],
+                max_tokens=500,
+                temperature=0.3
+            )
+            
+            translated_text = response.choices[0].message.content.strip()
+            logger.info(f"OpenAI translation successful: {translated_text[:100]}...")
+            return translated_text
+            
+        except Exception as e:
+            error_msg = str(e)
+            logger.error(f"Translation error: {error_msg}")
+            
+            # Check for quota exceeded error
+            if "429" in error_msg or "quota" in error_msg.lower() or "insufficient_quota" in error_msg.lower():
+                logger.warning("[WARNING] OpenAI API quota exceeded - using fallback translation")
+                target_name = self.supported_languages.get(target_lang, target_lang)
+                return f"[API Quota Exceeded] Please add credits to your OpenAI account. Original text: {text}"
+            
+            raise Exception(f"Translation failed: {error_msg}")
+
+    async def generate_speech_with_custom_voice(self, text: str, voice: str) -> str:
+        """Generate speech using Edge TTS with custom voice"""
+        try:
+            if not EDGE_TTS_AVAILABLE:
+                logger.warning("Edge TTS not available")
+                return None
+            
+            # Create temporary output file
+            temp_dir = tempfile.gettempdir()
+            output_path = os.path.join(temp_dir, f"tts_output_{int(time.time())}.wav")
+            
+            # Generate speech with specific voice
+            communicate = edge_tts.Communicate(text, voice)
+            await communicate.save(output_path)
+            
+            if os.path.exists(output_path):
+                logger.info(f"Edge TTS generated with {voice}: {output_path}")
+                return output_path
+            else:
+                return None
+                
+        except Exception as e:
+            logger.error(f"TTS Error: {e}")
+            return None
+
+    def process_audio_translation_with_voice(
+        self, 
+        audio_path: str, 
+        target_lang: str,
+        voice: str
+    ) -> Tuple[str, str, str, Optional[str]]:
+        """Complete audio translation pipeline with custom voice selection"""
+        
+        if not audio_path:
+            return "Please upload an audio file", "", "", None
+        
+        logger.info(f"Processing audio translation with auto-detection -> {target_lang} (voice: {voice})")
+        
+        # Step 1: Speech to text with OpenAI Whisper + Language Detection
+        logger.info("Step 1: Transcribing audio with language detection...")
+        transcribed_text, detected_language = self.speech_to_text(audio_path)
+        
+        if transcribed_text.startswith("Error"):
+            return transcribed_text, "", "", None
+        
+        logger.info(f"Transcription: {transcribed_text[:100]}...")
+        logger.info(f"Detected Language: {detected_language}")
+        
+        # Step 2: Translate text with OpenAI GPT-4o Mini using detected language
+        logger.info("Step 2: Translating text...")
+        # Map detected language name to code for translation
+        lang_code_map = {
+            'English': 'en', 'Vietnamese': 'vi', 'Spanish': 'es', 'French': 'fr',
+            'German': 'de', 'Italian': 'it', 'Portuguese': 'pt', 'Russian': 'ru',
+            'Japanese': 'ja', 'Korean': 'ko', 'Chinese': 'zh', 'Arabic': 'ar',
+            'Hindi': 'hi', 'Thai': 'th', 'Turkish': 'tr'
+        }
+        
+        detected_lang_code = lang_code_map.get(detected_language, 'en')
+        translated_text = self.translate_text(transcribed_text, detected_lang_code, target_lang)
+        
+        if translated_text.startswith("[Translation Error]"):
+            return transcribed_text, detected_language, translated_text, None
+        
+        logger.info(f"Translation: {translated_text[:100]}...")
+        
+        # Step 3: Generate speech with Edge TTS using custom voice
+        logger.info(f"Step 3: Generating speech with voice: {voice}")
+        audio_output = asyncio.run(self.generate_speech_with_custom_voice(translated_text, voice))
+        
+        if audio_output:
+            logger.info("Complete translation pipeline successful!")
+        else:
+            logger.warning("TTS generation failed, returning text only")
+        
+        return transcribed_text, detected_language, translated_text, audio_output
+
+# Initialize AI Agent
+agent = TranslationAIAgent()
+
+# Interface Functions
+def get_country_options() -> List[str]:
+    """Get country options with flags for target language"""
+    choices = []
+    for lang_code, lang_info in agent.language_voice_options.items():
+        for option in lang_info['options']:
+            choice = f"{option['code']} | {option['display']}"
+            choices.append(choice)
+    return sorted(choices)
+
+def get_voice_options_for_country(country_selection: str) -> List[str]:
+    """Get voice options for selected country"""
+    if not country_selection or '|' not in country_selection:
+        return ["Jenny (Female)", "Guy (Male)"]
+    
+    code = country_selection.split(' | ')[0].strip()
+    
+    for lang_info in agent.language_voice_options.values():
+        for option in lang_info['options']:
+            if option['code'] == code:
+                main_voice = option['voice'].replace('Neural', '').split('-')[-1]
+                alt_voice = option['alt_voice'].replace('Neural', '').split('-')[-1]
+                
+                def get_gender(voice_name):
+                    female_names = ['Jenny', 'Libby', 'Natasha', 'Clara', 'Elvira', 'Dalia', 'Denise', 'Sylvie', 'Katja', 'Elsa', 'Raquel', 'Francisca', 'Svetlana', 'Nanami', 'SunHi', 'Xiaoxiao', 'HoaiMy']
+                    return "(Female)" if any(name in voice_name for name in female_names) else "(Male)"
+                
+                return [
+                    f"{main_voice} {get_gender(main_voice)}",
+                    f"{alt_voice} {get_gender(alt_voice)}"
+                ]
+    
+    return ["Jenny (Female)", "Guy (Male)"]
+
+def get_voice_code_from_selections(country_selection: str, voice_selection: str) -> str:
+    """Get full voice code from country and voice selections"""
+    if not country_selection or '|' not in country_selection:
+        return 'en-US-JennyNeural'
+    
+    code = country_selection.split(' | ')[0].strip()
+    voice_name = voice_selection.split(' (')[0].strip()
+    
+    for lang_info in agent.language_voice_options.values():
+        for option in lang_info['options']:
+            if option['code'] == code:
+                main_voice_name = option['voice'].replace('Neural', '').split('-')[-1]
+                alt_voice_name = option['alt_voice'].replace('Neural', '').split('-')[-1]
+                
+                if voice_name == main_voice_name:
+                    return option['voice']
+                elif voice_name == alt_voice_name:
+                    return option['alt_voice']
+    
+    return 'en-US-JennyNeural'
+
+def get_language_code_from_country(country_selection: str) -> str:
+    """Extract language code from country selection"""
+    if not country_selection or '|' not in country_selection:
+        return 'en'
+    
+    code = country_selection.split(' | ')[0].strip()
+    return code.split('-')[0]
+
+def update_voice_options(country_selection: str) -> gr.Dropdown:
+    """Update voice dropdown based on country selection"""
+    voice_options = get_voice_options_for_country(country_selection)
+    return gr.Dropdown(choices=voice_options, value=voice_options[0] if voice_options else "Jenny (Female)")
+
+# Global conversation and audio state
+conversation_state = {
+    "person_a_messages": [],
+    "person_b_messages": [],
+    "person_a_translations": [],
+    "person_b_translations": [],
+    "latest_audio_for_a": None,  # Audio that Person A should hear
+    "latest_audio_for_b": None   # Audio that Person B should hear
+}
+
+def add_message_to_conversation(person, original, detected_lang, translation, target_person):
+    """Add message to global conversation state"""
+    if original and translation:
+        timestamp = time.strftime("%H:%M")
+        
+        if person == "A":
+            conversation_state["person_a_messages"].append(f"[{timestamp}] Person A ({detected_lang}): {original}")
+            conversation_state["person_b_translations"].append(f"[{timestamp}] -> Person B: {translation}")
+        else:  # person == "B"
+            conversation_state["person_b_messages"].append(f"[{timestamp}] Person B ({detected_lang}): {original}")
+            conversation_state["person_a_translations"].append(f"[{timestamp}] -> Person A: {translation}")
+
+def get_full_conversation():
+    """Get complete conversation history for both tabs"""
+    all_messages = []
+    max_length = max(
+        len(conversation_state["person_a_messages"]), 
+        len(conversation_state["person_b_messages"]),
+        len(conversation_state["person_a_translations"]),
+        len(conversation_state["person_b_translations"])
+    )
+    
+    for i in range(max_length):
+        if i < len(conversation_state["person_a_messages"]):
+            all_messages.append(conversation_state["person_a_messages"][i])
+        if i < len(conversation_state["person_b_translations"]):
+            all_messages.append(conversation_state["person_b_translations"][i])
+        if i < len(conversation_state["person_b_messages"]):
+            all_messages.append(conversation_state["person_b_messages"][i])
+        if i < len(conversation_state["person_a_translations"]):
+            all_messages.append(conversation_state["person_a_translations"][i])
+    
+    return "\n".join(all_messages[-10:])  # Show last 10 messages
+
+def translate_person_a_to_b(audio_file, country_b: str, voice_b: str) -> tuple[str, Optional[str]]:
+    """Person A speaks -> results appear in Person B's tab"""
+    if audio_file is None:
+        return "", None
+    
+    try:
+        print(f"[DEBUG] Person A recording: {audio_file}")
+        tgt_code = get_language_code_from_country(country_b)
+        selected_voice = get_voice_code_from_selections(country_b, voice_b)
+        print(f"[DEBUG] Target: {tgt_code}, Voice: {selected_voice}")
+        
+        original_text, detected_lang, translated_text, audio_output = agent.process_audio_translation_with_voice(
+            audio_file, tgt_code, selected_voice
+        )
+        
+        print(f"[DEBUG] Results: {original_text[:50]}... -> {translated_text[:50]}...")
+        print(f"[DEBUG] Audio output: {audio_output}")
+        
+        # Add to conversation
+        add_message_to_conversation("A", original_text, detected_lang, translated_text, "B")
+        
+        # Return conversation for Person B's tab and audio
+        conversation_history = get_full_conversation()
+        print(f"[DEBUG] Conversation length: {len(conversation_history)}")
+        
+        return conversation_history, audio_output
+        
+    except Exception as e:
+        print(f"[ERROR] translate_person_a_to_b: {e}")
+        return f"Error: {str(e)}", None
+
+def translate_person_b_to_a(audio_file, country_a: str, voice_a: str) -> tuple[str, Optional[str]]:
+    """Person B speaks -> results appear in Person A's tab"""
+    if audio_file is None:
+        return "", None
+    
+    try:
+        print(f"[DEBUG] Person B recording: {audio_file}")
+        tgt_code = get_language_code_from_country(country_a)
+        selected_voice = get_voice_code_from_selections(country_a, voice_a)
+        print(f"[DEBUG] Target: {tgt_code}, Voice: {selected_voice}")
+        
+        original_text, detected_lang, translated_text, audio_output = agent.process_audio_translation_with_voice(
+            audio_file, tgt_code, selected_voice
+        )
+        
+        print(f"[DEBUG] Results: {original_text[:50]}... -> {translated_text[:50]}...")
+        print(f"[DEBUG] Audio output: {audio_output}")
+        
+        # Add to conversation
+        add_message_to_conversation("B", original_text, detected_lang, translated_text, "A")
+        
+        # Return conversation for Person A's tab and audio
+        conversation_history = get_full_conversation()
+        print(f"[DEBUG] Conversation length: {len(conversation_history)}")
+        
+        return conversation_history, audio_output
+        
+    except Exception as e:
+        print(f"[ERROR] translate_person_b_to_a: {e}")
+        return f"Error: {str(e)}", None
+
+def get_audio_for_person_a() -> Optional[str]:
+    """Get latest audio that Person A should hear"""
+    return conversation_state.get("latest_audio_for_a")
+
+def get_audio_for_person_b() -> Optional[str]:
+    """Get latest audio that Person B should hear"""
+    return conversation_state.get("latest_audio_for_b")
+
+# Create Two-Person Translation Interface
+with gr.Blocks(
+    title="🎙️ Two-Person Live Translation",
+    theme=gr.themes.Soft(),
+    css="""
+    .gradio-container { max-width: 1400px !important; margin: 0 auto !important; }
+    .header {
+        text-align: center;
+        background: linear-gradient(135deg, #4A90E2 0%, #FF6B9D 100%);
+        color: white;
+        padding: 20px;
+        border-radius: 10px;
+        margin-bottom: 20px;
+    }
+    .status-box {
+        background: rgba(78, 205, 196, 0.1);
+        border: 2px solid rgba(78, 205, 196, 0.3);
+        border-radius: 10px;
+        padding: 15px;
+        text-align: center;
+        margin: 15px 0;
+    }
+    """
+) as demo:
+    
+    # Header
+    api_status = "Ready" if agent.openai_configured else "Missing API Key"
+    edge_tts_status = "Ready" if EDGE_TTS_AVAILABLE else "Not Available"
+    
+    gr.HTML(f"""
+    <div class="header">
+        <h1>🎙️ Two-Person Live Translation</h1>
+        <p>Real-time Cross-Translation between Person A & Person B</p>
+        <div style="margin-top: 15px;">
+            <span style="background: rgba(255,255,255,0.2); padding: 6px 12px; border-radius: 15px; margin: 0 5px;">
+                <strong>OpenAI:</strong> {api_status}
+            </span>
+            <span style="background: rgba(255,255,255,0.2); padding: 6px 12px; border-radius: 15px; margin: 0 5px;">
+                <strong>Edge TTS:</strong> {edge_tts_status}
+            </span>
+        </div>
+        <div style="margin-top: 10px;">🧠 <strong>Digitized Brains</strong></div>
+    </div>
+    """)
+
+    # Status Box
+    gr.HTML(f"""
+    <div class="status-box">
+        <h4>🤖 AI Pipeline Status</h4>
+        <div style="display: flex; justify-content: center; gap: 20px; flex-wrap: wrap;">
+            <span><strong>Whisper:</strong> {'Ready' if agent.openai_configured else 'Not Ready'}</span>
+            <span><strong>🧠 GPT-4o:</strong> {'🟢 Ready' if agent.openai_configured else '🔴 Not Ready'}</span>
+            <span><strong>🔊 TTS:</strong> {'🟢 Ready' if EDGE_TTS_AVAILABLE else '🔴 Not Ready'}</span>
+        </div>
+    </div>
+    """)
+
+    with gr.Tabs():
+        # Person A Tab - Only shows translation FROM Person B
+        with gr.TabItem("Person A View"):
+            gr.Markdown("### Person A receives translations from Person B")
+            
+            # Conversation History for Person A
+            conversation_display_a = gr.Textbox(
+                label="Full Conversation",
+                lines=8,
+                interactive=False,
+                placeholder="Conversation will appear here...",
+                value=""
+            )
+            
+            with gr.Row():
+                with gr.Column(scale=2):
+                    mic_a = gr.Audio(
+                        sources=["microphone"],
+                        type="filepath",
+                        label="Person A: Record Your Voice"
+                    )
+                    
+                with gr.Column(scale=1):
+                    country_b_for_a = gr.Dropdown(
+                        choices=get_country_options(),
+                        label="Person B's Language",
+                        value="vi-vn | Vietnamese (Vietnam)"
+                    )
+                    voice_b_for_a = gr.Dropdown(
+                        choices=["HoaiMy (Female)", "NamMinh (Male)"],
+                        label="Person B's Voice",
+                        value="HoaiMy (Female)"
+                    )
+            
+            # Only show audio FROM Person B (Person A hears this)
+            audio_from_b = gr.Audio(
+                label="🔊 Translation Audio from Person B",
+                interactive=False,
+                value=None
+            )
+
+        # Person B Tab - Only shows translation FROM Person A  
+        with gr.TabItem("Person B View"):
+            gr.Markdown("### Person B receives translations from Person A")
+            
+            # Conversation History for Person B
+            conversation_display_b = gr.Textbox(
+                label="Full Conversation",
+                lines=8,
+                interactive=False,
+                placeholder="Conversation will appear here...",
+                value=""
+            )
+            
+            with gr.Row():
+                with gr.Column(scale=2):
+                    mic_b = gr.Audio(
+                        sources=["microphone"],
+                        type="filepath",
+                        label="Person B: Record Your Voice"
+                    )
+                    
+                with gr.Column(scale=1):
+                    country_a_for_b = gr.Dropdown(
+                        choices=get_country_options(),
+                        label="Person A's Language",
+                        value="en-us | English (United States)"
+                    )
+                    voice_a_for_b = gr.Dropdown(
+                        choices=["Jenny (Female)", "Guy (Male)"],
+                        label="Person A's Voice",
+                        value="Jenny (Female)"
+                    )
+            
+            # Only show audio FROM Person A (Person B hears this)
+            audio_from_a = gr.Audio(
+                label="🔊 Translation Audio from Person A",
+                interactive=False,
+                value=None
+            )
+
+    # Event Handlers
+    # Person A -> Person B
+    country_b_for_a.change(
+        fn=update_voice_options,
+        inputs=[country_b_for_a],
+        outputs=[voice_b_for_a]
+    )
+    
+    # Person A records -> Audio & translation appears in Person B's tab
+    mic_a.change(
+        fn=translate_person_a_to_b,
+        inputs=[mic_a, country_b_for_a, voice_b_for_a],
+        outputs=[conversation_display_b, audio_from_a]  # Results appear in Person B's tab
+    )
+    
+    # Person B -> Person A
+    country_a_for_b.change(
+        fn=update_voice_options,
+        inputs=[country_a_for_b],
+        outputs=[voice_a_for_b]
+    )
+    
+    # Person B records -> Audio & translation appears in Person A's tab
+    mic_b.change(
+        fn=translate_person_b_to_a,
+        inputs=[mic_b, country_a_for_b, voice_a_for_b],
+        outputs=[conversation_display_a, audio_from_b]  # Results appear in Person A's tab
+    )
+
+if __name__ == "__main__":
+    print("===== Two-Person Live Translation Startup =====")
+    print("Starting Two-Person Live Translation")
+    print(f"OpenAI API Status: {'Ready' if agent.openai_configured else 'Missing - Set OPENAI_API_KEY'}")
+    print(f"Edge TTS Status: {'Ready' if EDGE_TTS_AVAILABLE else 'Not Available'}")
+    
+    if agent.openai_configured:
+        print("Production Mode - Real AI Translation enabled")
+        print("Translation Model: GPT-4o-mini")
+        print("Speech Recognition: OpenAI Whisper-1")
+    else:
+        print("Demo Mode - Configure OPENAI_API_KEY for full functionality")
+    
+    # Use environment port or default (7901 for testing)
+    port = int(os.environ.get("GRADIO_SERVER_PORT", 7901))
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=port,
+        share=False,
+        show_error=True
+    )