Update app.py

app.py

@@ -1,26 +1,369 @@
 # =====================================================================
-# ── ARCHIVO PRINCIPAL DE ARRANQUE ENLAZADO: app.py ──
+# ── MÓDULO DE VOZ CV VISION (ENTORNO ROBUSTO POR HTTP VAD) ──
 # =====================================================================
+import os
+import io
+import base64
+import requests
+import warnings
 import gradio as gr
-from fastapi import FastAPI
 
-# 1. Inicializamos un objeto FastAPI global para tomar el control total de las rutas
-app_global = FastAPI()
+# Silenciamos advertencias de sintaxis de los modelos generativos
+warnings.filterwarnings("ignore", category=UserWarning, module="langchain_google_genai")
 
-# 2. Importamos el inyector del túnel WebSocket de Deepgram
-from modules.langchain_assistant.voice_module import mount_voice_websocket
+# Clave de acceso directa para Deepgram REST API
+DEEPGRAM_API_KEY = os.getenv("DEEPGRAM_API_KEY", "ba998efd03dae16398f44fc599dd0291367fe7ac")
 
-# 3. Montamos el proxy local de voz de forma nativa en la app global antes de compilar la UI
-mount_voice_websocket(app_global)
-print("🚀 [CVISION CORE] Túnel WebSocket Proxy de Deepgram inyectado globalmente.")
+# Variable Singleton global para mantener el cerebro vivo sin reinstanciar en cada frase
+_GLOBAL_CHAT_ASSISTANT = None
 
-# 4. Importamos la interfaz de Gradio
-from modules.interface import assistant_app
+def mount_voice_websocket(app):
+    """Mantiene compatibilidad estructural con app.py sin interferir en los puertos"""
+    pass
 
-# 5. Acoplamos de forma segura la interfaz de Gradio dentro de nuestra app global controlada
-app = gr.mount_gradio_app(app_global, assistant_app, path="/")
+def get_or_create_voice_brain():
+    """Garantiza una única instancia en memoria para eliminar la latencia de carga."""
+    global _GLOBAL_CHAT_ASSISTANT
+    if _GLOBAL_CHAT_ASSISTANT is None:
+        try:
+            from modules.langchain_assistant.langchain_chat_assistant import LangChainChatAssistant
+            _GLOBAL_CHAT_ASSISTANT = LangChainChatAssistant()
+        except Exception as e:
+            print(f"❌ [CVISION VOICE ERR] No se pudo instanciar el cerebro principal: {str(e)}")
+    return _GLOBAL_CHAT_ASSISTANT
 
-if __name__ == "__main__":
-    import uvicorn
-    print("🌌 [CVISION CORE] Inicializando entorno visual Cybernova en puerto oficial 7860...")
-    uvicorn.run(app, host="0.0.0.0", port=7860, log_level="info")
+def process_audio_base64(base64_audio_str, history_state):
+    """
+    Procesa el audio recibido por chunks de VAD, realiza STT, consulta al cerebro único 
+    de LangChain y genera la síntesis de voz en memoria RAM de forma ultra-rápida.
+    """
+    if not base64_audio_str or len(base64_audio_str.strip()) < 50:
+        return None, history_state, "DONE"
+        
+    if history_state is None:
+        history_state = []
+
+    try:
+        # 1. Decodificación de audio enviado desde la RAM del navegador
+        header, encoded = base64_audio_str.split(",", 1) if "," in base64_audio_str else ("", base64_audio_str)
+        audio_data = base64.b64decode(encoded)
+        
+        # 2. STT Nativo vía HTTP (Deepgram Nova-2)
+        url_stt = "https://api.deepgram.com/v1/listen?model=nova-2&language=es&smart_format=true"
+        headers_stt = {
+            "Authorization": f"Token {DEEPGRAM_API_KEY}",
+            "Content-Type": "audio/webm"
+        }
+        
+        response_stt = requests.post(url_stt, headers=headers_stt, data=audio_data, timeout=8)
+        if response_stt.status_code != 200:
+            return None, history_state, "DONE"
+            
+        stt_json = response_stt.json()
+        user_text = stt_json['results']['channels'][0]['alternatives'][0]['transcript']
+        
+        if not user_text.strip() or len(user_text.strip()) < 2:
+            return None, history_state, "DONE"
+            
+        print(f"🎙️ [CVISION VOICE] Cristian: {user_text}")
+        
+        # 3. Consulta Cognitiva al Singleton de LangChain
+        cerebro = get_or_create_voice_brain()
+        if cerebro:
+            prompt_conversacional = (
+                f"{user_text} (REGLA CRÍTICA: Responde de forma puramente hablada, corta, "
+                f"en un solo párrafo fluido, sin usar código, viñetas, asteriscos ni símbolos matemáticos como $ o *. "
+                f"Escribe los números con letras, por ejemplo: cuatro en vez de 4)"
+            )
+            ai_response = cerebro.chat(input=prompt_conversacional)
+        else:
+            ai_response = "Enlace de inteligencia de LangChain fuera de línea."
+
+        print(f"🤖 [CVISION VOICE] Javier: {ai_response}")
+        
+        # 4. TTS Nativo vía HTTP procesado directamente sobre memoria virtual (RAM)
+        url_tts = "https://api.deepgram.com/v1/speak?model=aura-2-javier-es&encoding=mp3"
+        headers_tts = {
+            "Authorization": f"Token {DEEPGRAM_API_KEY}",
+            "Content-Type": "application/json"
+        }
+        payload_tts = {"text": ai_response}
+        
+        response_tts = requests.post(url_tts, headers=headers_tts, json=payload_tts, timeout=8)
+        
+        if response_tts.status_code == 200:
+            # Codificación directa en buffer binario sin tocar el disco duro
+            audio_buffer = io.BytesIO(response_tts.content)
+            encoded_output = base64.b64encode(audio_buffer.read()).decode("utf-8")
+            audio_uri = f"data:audio/mp3;base64,{encoded_output}"
+        else:
+            return None, history_state, "DONE"
+            
+        # Actualizamos el historial del componente visual
+        history_state.append((user_text, ai_response))
+        return audio_uri, history_state, "DONE"
+
+    except Exception as e:
+        print(f"❌ [CVISION VOICE PIPELINE CRASH]: {str(e)}")
+        return None, history_state, "DONE"
+
+# =====================================================================
+# ── SECCIÓN UI: INTERFAZ PLAYGROUND ADAPTADA ──
+# =====================================================================
+def create_voice_tab():
+    with gr.TabItem("🎙️ MODO VOZ", elem_id="voice_tab"):
+        
+        audio_bridge_in = gr.Textbox(visible=False, elem_id="audio_bridge_in")
+        audio_bridge_out = gr.Textbox(visible=False, elem_id="audio_bridge_out")
+        control_bridge = gr.Textbox(visible=False, elem_id="control_bridge")
+        
+        gr.HTML(
+            """
+            <div style='text-align: center; padding: 15px;'>
+                <div class='hud-neon-glow' style='font-size: 24px; font-weight: bold; text-shadow: 0 0 10px #00f0ff; color: #fff; margin-bottom: 5px;'>
+                    CVISION INTELLIGENCE — COGNITIVE PLAYGROUND
+                </div>
+                <p style='color: #00f0ff; font-family: monospace; letter-spacing: 1px; font-size: 11px; margin: 0;'>
+                    HTTP PIPELINE CON DETECCIÓN DE SILENCIO ACTIVA (VAD)
+                </p>
+            </div>
+            """
+        )
+        
+        with gr.Row():
+            with gr.Column(scale=1, variant="panel", elem_id="voice_panel_container"):
+                gr.HTML(
+                    """
+                    <div style="display: flex; flex-direction: column; align-items: center; justify-content: center; margin: 20px 0;">
+                        <div id="cyber_sphere" style="width: 130px; height: 130px; border-radius: 50%; border: 4px solid #3a3a4a; box-shadow: 0 0 15px #1a1a2e; display: flex; align-items: center; justify-content: center; transition: all 0.3s ease;">
+                            <div id="cyber_core" style="width: 90px; height: 90px; border-radius: 50%; background: radial-gradient(circle, #111 40%, #222 100%); transition: all 0.3s ease;"></div>
+                        </div>
+                        <div id="cyber_status_text" style="color: #64dfdf; font-family: monospace; font-size: 13px; margin-top: 20px; letter-spacing: 2px; font-weight: bold; text-align: center;">
+                            [ CANAL DE VOZ APAGADO ]
+                        </div>
+                    </div>
+                    <audio id="cyber_native_speaker"></audio>
+                    """
+                )
+                with gr.Row():
+                    start_voice_btn = gr.Button("▶️ ENCENDER AGENTE", variant="primary", elem_id="btn_start_voice_core")
+                    stop_voice_btn = gr.Button("🛑 APAGAR AGENTE", variant="stop", elem_id="btn_stop_voice_core")
+            
+            with gr.Column(scale=2):
+                chatbot_display = gr.Chatbot(
+                    label="Transcripción de la Conversación", 
+                    elem_id="voice_history_chatbot",
+                    bubble_full_width=False,
+                    height=300
+                )
+
+        # =====================================================================
+        # ── INTERCEPTOR JAVASCRIPT: FILTRO WEB AUDIO CON VAD NATIVO ──
+        # =====================================================================
+        gr.HTML(
+            """
+            <script>
+            if (window.cyber_voice_initialized === undefined) {
+                window.cyber_voice_initialized = true;
+                
+                let mediaRecorder = null;
+                let audioChunks = [];
+                let isVoiceActive = false;
+                let isProcessingBackend = false; 
+                let globalStream = null;
+                let audioContext = null;
+                let analyser = null;
+                
+                // Configuración del Umbral de Silencio (VAD)
+                const VOICE_MIN_DECIBELS = -55; 
+                const SILENCE_DURATION_MS = 1100; // Envía tras 1.1 segundos de silencio continuos
+                let lastVoiceDetectedTime = Date.now();
+                let vadInterval = null;
+                
+                function setHUD(text, color, pulse) {
+                    const txt = document.getElementById("cyber_status_text");
+                    const sphere = document.getElementById("cyber_sphere");
+                    const core = document.getElementById("cyber_core");
+                    if (txt) txt.innerText = text;
+                    if (sphere) { sphere.style.borderColor = color; sphere.style.boxShadow = `0 0 25px ${color}`; }
+                    if (core) core.style.background = pulse ? `radial-gradient(circle, ${color} 20%, #111 80%)` : 'radial-gradient(circle, #111 40%, #222 100%)';
+                }
+                
+                async function startVoicePipeline() {
+                    if (isVoiceActive) return;
+                    setHUD("[ INICIALIZANDO MICRÓFONO... ]", "#ffa502", false);
+                    
+                    try {
+                        globalStream = await navigator.mediaDevices.getUserMedia({ audio: true });
+                        isVoiceActive = true;
+                        isProcessingBackend = false;
+                        setHUD("[ AGENTE EN VIVO — TE ESCUCHO ]", "#00f0ff", true);
+                        
+                        // Configuración del analizador Web Audio para VAD
+                        audioContext = new (window.AudioContext || window.webkitAudioContext)();
+                        const source = audioContext.createMediaStreamSource(globalStream);
+                        analyser = audioContext.createAnalyser();
+                        analyser.fftSize = 512;
+                        analyser.minDecibels = -90;
+                        analyser.maxDecibels = -10;
+                        analyser.smoothingTimeConstant = 0.85;
+                        source.connect(analyser);
+                        
+                        triggerAudioCapture();
+                        startVADMonitor();
+                    } catch (err) {
+                        console.error(err);
+                        setHUD("[ ERROR MULTIMEDIA DE ACCESO ]", "#ff4757", false);
+                    }
+                }
+                
+                function triggerAudioCapture() {
+                    if (!isVoiceActive || isProcessingBackend) return;
+                    
+                    audioChunks = [];
+                    mediaRecorder = new MediaRecorder(globalStream, { mimeType: 'audio/webm' });
+                    
+                    mediaRecorder.ondataavailable = e => { 
+                        if (e.data.size > 0) audioChunks.push(e.data); 
+                    };
+                    
+                    mediaRecorder.onstop = async () => {
+                        if (audioChunks.length > 0 && isVoiceActive && !isProcessingBackend) {
+                            isProcessingBackend = true; 
+                            setHUD("[ JAVIER PROCESANDO... ]", "#ffa502", true);
+                            
+                            const audioBlob = new Blob(audioChunks, { type: 'audio/webm' });
+                            const reader = new FileReader();
+                            reader.readAsDataURL(audioBlob);
+                            reader.onloadend = () => {
+                                const inputBridge = document.querySelector("#audio_bridge_in textarea");
+                                if (inputBridge) {
+                                    inputBridge.value = reader.result;
+                                    inputBridge.dispatchEvent(new Event('input', { bubbles: true }));
+                                }
+                            };
+                        }
+                    };
+                    
+                    mediaRecorder.start();
+                    lastVoiceDetectedTime = Date.now();
+                }
+                
+                function startVADMonitor() {
+                    const bufferLength = analyser.frequencyBinCount;
+                    const dataArray = new Float32Array(bufferLength);
+                    
+                    vadInterval = setInterval(() => {
+                        if (!isVoiceActive || isProcessingBackend || !mediaRecorder) return;
+                        
+                        analyser.getFloatFrequencyData(dataArray);
+                        
+                        // Buscamos si hay alguna frecuencia que supere el umbral mínimo de voz humana
+                        let hasVoice = false;
+                        for (let i = 0; i < bufferLength; i++) {
+                            if (dataArray[i] > VOICE_MIN_DECIBELS) {
+                                hasVoice = true;
+                                break;
+                            }
+                        }
+                        
+                        const now = Date.now();
+                        if (hasVoice) {
+                            lastVoiceDetectedTime = now;
+                        } else if (now - lastVoiceDetectedTime > SILENCE_DURATION_MS) {
+                            // Si se superó el tiempo de silencio y está grabando, cortamos para enviar inmediatamente
+                            if (mediaRecorder.state === "recording") {
+                                mediaRecorder.stop();
+                            }
+                        }
+                    }, 100);
+                }
+                
+                function stopVoicePipeline() {
+                    isVoiceActive = false;
+                    isProcessingBackend = false;
+                    setHUD("[ CANAL DE VOZ APAGADO ]", "#3a3a4a", false);
+                    
+                    if (vadInterval) { clearInterval(vadInterval); vadInterval = null; }
+                    
+                    const nativePlayer = document.getElementById("cyber_native_speaker");
+                    if (nativePlayer) nativePlayer.pause();
+                    
+                    if (mediaRecorder && mediaRecorder.state !== "inactive") {
+                        mediaRecorder.stop();
+                    }
+                    if (globalStream) {
+                        globalStream.getTracks().forEach(track => track.stop());
+                    }
+                    if (audioContext && audioContext.state !== 'closed') {
+                        audioContext.close();
+                    }
+                }
+                
+                // Monitor reactivo de respuesta de audio e interrupciones dinámicas
+                setInterval(() => {
+                    const outputBridge = document.querySelector("#audio_bridge_out textarea");
+                    const nativePlayer = document.getElementById("cyber_native_speaker");
+                    const ctrlBridge = document.querySelector("#control_bridge textarea");
+                    
+                    if (outputBridge && outputBridge.value && outputBridge.value.trim() !== "") {
+                        setHUD("[ JAVIER HABLANDO ]", "#00ff88", true);
+                        if (nativePlayer) {
+                            nativePlayer.src = outputBridge.value;
+                            nativePlayer.play()
+                                .then(() => {
+                                    nativePlayer.onended = () => {
+                                        setHUD("[ AGENTE EN VIVO — TE ESCUCHO ]", "#00f0ff", true);
+                                        isProcessingBackend = false;
+                                        if (ctrlBridge) {
+                                            ctrlBridge.value = "";
+                                            ctrlBridge.dispatchEvent(new Event('input', { bubbles: true }));
+                                        }
+                                        // Reenganche automático e instantáneo del ciclo infinito
+                                        setTimeout(() => { triggerAudioCapture(); }, 50);
+                                    };
+                                })
+                                .catch(e => {
+                                    isProcessingBackend = false;
+                                    setHUD("[ AGENTE EN VIVO — TE ESCUCHO ]", "#00f0ff", true);
+                                    setTimeout(() => { triggerAudioCapture(); }, 50);
+                                });
+                        }
+                        outputBridge.value = ""; 
+                        outputBridge.dispatchEvent(new Event('input', { bubbles: true }));
+                    }
+                    
+                    if (ctrlBridge && ctrlBridge.value === "DONE" && isProcessingBackend) {
+                        ctrlBridge.value = "";
+                        ctrlBridge.dispatchEvent(new Event('input', { bubbles: true }));
+                        setTimeout(() => {
+                            const nativePlayer = document.getElementById("cyber_native_speaker");
+                            if (!nativePlayer || nativePlayer.paused) {
+                                isProcessingBackend = false;
+                                setHUD("[ AGENTE EN VIVO — TE ESCUCHO ]", "#00f0ff", true);
+                                triggerAudioCapture();
+                            }
+                        }, 2000);
+                    }
+                }, 100);
+                
+                document.addEventListener("DOMContentLoaded", () => {
+                    setTimeout(() => {
+                        const btnStart = document.getElementById("btn_start_voice_core");
+                        const btnStop = document.getElementById("btn_stop_voice_core");
+                        if (btnStart) btnStart.onclick = startVoicePipeline;
+                        if (btnStop) btnStop.onclick = stopVoicePipeline;
+                    }, 1200);
+                });
+            }
+            </script>
+            """
+        )
+        
+        # Conexión síncrona reactiva en Gradio
+        audio_bridge_in.change(
+            fn=process_audio_base64,
+            inputs=[audio_bridge_in, chatbot_display],
+            outputs=[audio_bridge_out, chatbot_display, control_bridge],
+            show_progress="none"
+        )