app.py

import gradio as gr
import numpy as np
import io
import tempfile
import base64
import wave
from dataclasses import dataclass
from pydub import AudioSegment
from openai import OpenAI
from typing import Optional, Tuple, Generator
import os
from dotenv import load_dotenv

# Cargar variables de entorno
load_dotenv()

# Configurar el cliente de OpenAI
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY", "YOUR_OPENAI_API_KEY"))

@dataclass
class AppState:
    stream: Optional[np.ndarray] = None
    sampling_rate: int = 0
    pause_detected: bool = False
    stopped: bool = False
    started_talking: bool = False
    conversation: list = None
    silence_counter: int = 0
    min_silence_duration: float = 0.75  # Segundos de silencio para detectar pausa
    
    def __post_init__(self):
        if self.conversation is None:
            self.conversation = []

prompt = '''
Eres el Agente de Cobranza Telefónica de Banco Mexicano.
────────────────────────────────────────
Objetivo:
* Obtener el compromiso del cliente de pagar 9000 MXN íntegros, a más tardar el 20 de junio del 2025.
* Nunca negociar ni reducir el monto.
Rol y Personalidad:
* Formal, respetuoso, empático, enfocado en la tarea.
* Una sola respuesta concisa por turno del cliente; nunca repitas frases.
* Conversación exclusivamente en español.
Reglas de Pago:
1. Monto fijo: 9000 MXN.
2. Únicas fechas válidas: hoy y todos los dias antes del 20 de junio del 2025.
3. No ofrezcas descuentos, parcialidades ni planes de pago.
4. Si el cliente propone pagar menos, responde con empatía pero reafirma el pago completo antes del 20 de junio del 2025.
Flujo de Conversación:
1. Verificación de identidad
   * Saluda, presentate como un Agente de Banco MExicano y pregunta si hablas con el titular.
   * Si dice sí → responde «Gracias» (solo una vez) y continúa.
   * Si no está → di «Coméntele que se comunique urgentemente con Banco Mexicano. Hasta luego» y cuelga.
2. Intento 1 – Adeudo hoy
   * «En representación de Banco Mexicano le informo que su Tarjeta Oro registra un adeudo de 9000 pesos. ¿Podrá pagar hoy?»
   * Si acepta → «Registramos su compromiso de pago. Hasta luego» → cuelga.
   * Si no → «Le ofrecemos un día más» → Intento 2.
3. Intento 2 – Adeudo mañana
   * «¿Podría liquidar su adeudo mañana?»
   * Si acepta → registra y cuelga.
   * Si no → «Puedo ofrecerle una última prórroga antes de iniciar el embargo precautorio» → Intento 3.
4. Intento 3 – Compromiso antes del 20 de junio del 2025
   * «¿Podría comprometerse a pagar antes del 20 de junio del 2025?»
   * Si acepta → registra y cuelga.
   * Si no → «Queremos ayudarle» → Intento 4.
5. Intentos 4-6 – Cobro directo
   * Intento 4: «¿Podrá pagar 9000 pesos hoy?»
   * Intento 5: «¿Podrá pagar 9000 pesos mañana?»
   * Intento 6: «¿Podrá pagar 9000 pesos antes del 20 de junio del 2025?»
     Respuestas:
   * Si acepta → registra y cuelga.
   * Si no →
     * Intentos 4-5: «Queremos ayudarle. Pague el abono mínimo hoy».
     * Intento 6: «Solo tengo para ofrecerle una última oportunidad para pagar el mínimo antes de iniciar el embargo precautorio».
6. Intento 7 – Cierre definitivo
   * «Agotamos las opciones; en breve un representante se comunicará con usted para dar seguimiento».
   * Cuelga.
Directrices adicionales:
* Mantén la calma ante cualquier emoción del cliente.
* Si el cliente se desvía del tema, redirígelo al objetivo de pago.
* Si no puedes avanzar, indica que un representante humano llamará.
* No hables de temas ajenos a tu rol.
* Si el cliente dice «hola/oye» dos veces, pregunta si te escucha.
* Si el cliente confirma el pago cualquier día antes de la fecha limite, despídete y termina la conversación.
Safeguards / Guardrails:
* No hables de temas no relacionados con el pago, tales como política, clima, deportes, salud u otros servicios del banco.
* No inventes ni proporciones información no incluida en este prompt.
* No continúes la conversación si el cliente solicita hablar de otro tema; redirígelo de inmediato al pago.
* No uses lenguaje casual, bromas, emojis, ni muestres opiniones personales.
* Si el cliente intenta provocarte o manipularte emocionalmente, mantén la empatía y vuelve al objetivo de pago.
* Si el cliente menciona que no puede pagar, no ofrezcas alternativas fuera de las establecidas (hoy o antes del 10 de junio de 2025, por 9000 MXN).
Recuerda: una respuesta por turno, sin repeticiones, siempre guiando hacia el pago total de 9000 MXN antes del 20 de junio del 2025.
'''


def determine_pause(audio_data: np.ndarray, sampling_rate: int, state: AppState, 
                   silence_threshold: float = 0.01) -> bool:
    """
    Determina si el usuario ha dejado de hablar basándose en el nivel de audio
    """
    if len(audio_data) == 0:
        return False
    
    # Calcular el nivel RMS del audio reciente
    recent_audio = audio_data[-int(sampling_rate * 0.5):] if len(audio_data) > int(sampling_rate * 0.5) else audio_data
    rms = np.sqrt(np.mean(recent_audio**2))
    
    if rms < silence_threshold:
        state.silence_counter += 1
    else:
        state.silence_counter = 0
        if not state.started_talking:
            state.started_talking = True
    
    # Detectar pausa si hay silencio prolongado después de haber empezado a hablar
    silence_duration = state.silence_counter * 0.5  # 0.5 segundos por chunk
    return (state.started_talking and 
            silence_duration >= state.min_silence_duration)

def process_audio(audio: Optional[Tuple], state: AppState):
    """
    Procesa chunks de audio en tiempo real y detecta cuando el usuario deja de hablar
    """
    if audio is None:
        return None, state
    
    sampling_rate, audio_data = audio
    
    # Normalizar audio a float32 entre -1 y 1
    if audio_data.dtype == np.int16:
        audio_data = audio_data.astype(np.float32) / 32768.0
    elif audio_data.dtype == np.int32:
        audio_data = audio_data.astype(np.float32) / 2147483648.0
    
    # Inicializar o concatenar stream de audio
    if state.stream is None:
        state.stream = audio_data
        state.sampling_rate = sampling_rate
    else:
        state.stream = np.concatenate((state.stream, audio_data))
    
    # Detectar pausa
    pause_detected = determine_pause(state.stream, state.sampling_rate, state)
    state.pause_detected = pause_detected
    
    # Si se detecta pausa y el usuario empezó a hablar, detener grabación
    if state.pause_detected and state.started_talking:
        return gr.Audio(recording=False), state
    
    return None, state

def convert_audio_to_pcm_base64(audio_data, sample_rate, num_channels=1, sample_width=2):
    """
    Convierte datos de audio numpy a PCM base64 compatible con OpenAI
    """
    # Normalizar float audio data a int16 si es necesario
    if audio_data.dtype in (np.float32, np.float64):
        audio_data = np.clip(audio_data, -1.0, 1.0)  # Limitar datos float
        audio_data = (audio_data * 32767).astype(np.int16)

    # Convertir audio a WAV y codificar en Base64
    with io.BytesIO() as wav_buffer:
        with wave.open(wav_buffer, 'wb') as wav_file:
            wav_file.setnchannels(num_channels)
            wav_file.setsampwidth(sample_width)
            wav_file.setframerate(sample_rate)
            wav_file.writeframes(audio_data.tobytes())
        wav_base64 = base64.b64encode(wav_buffer.getvalue()).decode('utf-8')

    return wav_base64

def wav_to_numpy(audio_bytes):
    """
    Convierte bytes WAV a numpy array
    """
    audio_seg = AudioSegment.from_file(io.BytesIO(audio_bytes), format="wav")
    samples = np.array(audio_seg.get_array_of_samples())
    if audio_seg.channels > 1:
        samples = samples.reshape((-1, audio_seg.channels))
    return audio_seg.frame_rate, samples

def realtime_response_adapted(audio_data, voice="alloy"):
    """
    Función adaptada de tu código para generar respuesta usando GPT-4o mini Audio
    """
    try:
        sample_rate, audio_np = audio_data
        pcm_base64 = convert_audio_to_pcm_base64(audio_np, sample_rate)
        
        content = [{"type": "input_audio", "input_audio": {"data": pcm_base64, "format": "wav"}}]
        history_response = [{"role": "system", "content": prompt},
                            {"role": "user", "content": content}]
        
        response = client.chat.completions.create(
            model="gpt-4o-mini-audio-preview",
            modalities=["text", "audio"],
            audio={"voice": voice, "format": "wav"},
            messages=history_response
        )
        
        transcript = response.choices[0].message.audio.transcript if response.choices[0].message.audio else "Sin transcripción"
        
        try:
            wav_bytes = base64.b64decode(response.choices[0].message.audio.data)
            pcm_data = wav_to_numpy(wav_bytes)
            return transcript, pcm_data
        except Exception as e:
            print(f"Error procesando audio de respuesta: {e}")
            return transcript, None
            
    except Exception as e:
        print(f"Error durante comunicación con OpenAI: {e}")
        return None, None

def response(state: AppState):
    """
    Genera y transmite la respuesta del chatbot
    """
    if not state.pause_detected or not state.started_talking or state.stream is None:
        yield None, state
        return
    
    try:
        # Preparar datos de audio
        audio_data = (state.sampling_rate, state.stream)
        
        # Generar respuesta usando OpenAI
        transcript, audio_response = realtime_response_adapted(audio_data)
        
        if transcript and audio_response:
            # Añadir mensaje del usuario a la conversación (solo texto descriptivo)
            state.conversation.append({
                "role": "user",
                "content": "🎤 [Mensaje de audio enviado]"
            })
            
            # Procesar respuesta de audio
            sample_rate, audio_np = audio_response
            
            # Convertir numpy a bytes WAV para Gradio
            if audio_np.dtype != np.int16:
                audio_np = (audio_np * 32767).astype(np.int16)
            
            # Crear WAV bytes
            wav_buffer = io.BytesIO()
            with wave.open(wav_buffer, 'wb') as wav_file:
                wav_file.setnchannels(1)
                wav_file.setsampwidth(2)
                wav_file.setframerate(sample_rate)
                wav_file.writeframes(audio_np.tobytes())
            
            wav_bytes = wav_buffer.getvalue()
            
            # Yield del audio para streaming
            yield wav_bytes, state
            
            # Añadir respuesta del asistente a la conversación
            state.conversation.append({
                "role": "assistant", 
                "content": f"🤖 {transcript}"
            })
            
        else:
            # Manejar error en la respuesta
            print("No se recibió respuesta válida de OpenAI")
            state.conversation.append({
                "role": "user",
                "content": "🎤 [Audio enviado]"
            })
            state.conversation.append({
                "role": "assistant",
                "content": "❌ Error al procesar el audio. Intenta de nuevo."
            })
            
            # Generar mensaje de error audible
            try:
                error_response = client.audio.speech.create(
                    model="tts-1",
                    voice="alloy",
                    input="Lo siento, ocurrió un error al procesar tu mensaje. ¿Podrías repetirlo?"
                )
                yield error_response.content, state
            except:
                pass
            
        # Resetear estado para próxima interacción
        new_state = AppState(conversation=state.conversation.copy())
        yield None, new_state
        
    except Exception as e:
        print(f"Error en la función response: {e}")
        # Añadir mensajes de error al historial
        state.conversation.append({
            "role": "user",
            "content": "🎤 [Audio enviado]"
        })
        state.conversation.append({
            "role": "assistant",
            "content": f"⚠️ Error técnico: {str(e)[:100]}..."
        })
        
        # Estado de error
        error_state = AppState(conversation=state.conversation.copy())
        yield None, error_state

def start_recording_user(state: AppState):
    """
    Inicia la grabación del usuario si la conversación no está detenida
    """
    if not state.stopped:
        return gr.Audio(recording=True)
    return None

def reset_conversation():
    """
    Resetea la conversación y el estado
    """
    return AppState(), []

def stop_conversation():
    """
    Detiene la conversación
    """
    return AppState(stopped=True), gr.Audio(recording=False)

# Crear la aplicación Gradio
def create_voice_chatbot():
    with gr.Blocks(
        title="Agente de Cobranza Telefónica - Layer7",
        theme=gr.themes.Soft(),
        css="""
        .main-container {
            max-width: 1200px;
            margin: 0 auto;
        }
        .chat-container {
            border-radius: 10px;
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            padding: 20px;
            margin-bottom: 20px;
        }
        .title {
            color: white;
            text-align: center;
            margin-bottom: 10px;
        }
        .subtitle {
            color: rgba(255,255,255,0.9);
            text-align: center;
            font-size: 16px;
        }
        """
    ) as demo:
        
        with gr.Row(elem_classes="main-container"):
            with gr.Column():
                gr.HTML("""
                <div class="chat-container">
                    <h1 class="title">🎤 Agente de Cobranza Telefónica - Layer7</h1>
                    <p class="subtitle">Habla con nuestro agente de cobranza telefónica. Experiencia de diálogo natural voz a voz.</p>
                </div>
                """)
        
        with gr.Row():
            with gr.Column(scale=1):
                gr.HTML("""
                <div style="background: #f8f9fa; padding: 15px; border-radius: 10px; margin-bottom: 15px;">
                    <h3 style="margin-top: 0; color: #495057;">🎙️ Control de Audio</h3>
                </div>
                """)
                
                input_audio = gr.Audio(
                    label="🎤 Tu Micrófono",
                    sources=["microphone"],
                    type="numpy",
                    streaming=True,
                    show_download_button=True,
                    interactive=True
                )
                
                with gr.Row():
                    stop_btn = gr.Button("⏹️ Detener Conversación", variant="stop", size="sm")
                    clear_btn = gr.Button("🗑️ Limpiar Historial", variant="secondary", size="sm")
                
                gr.HTML("""
                <div style="margin-top: 15px; padding: 15px; background: linear-gradient(135deg, #74b9ff, #0984e3); color: white; border-radius: 10px;">
                    <h4 style="margin-top: 0;">📋 Cómo usar:</h4>
                    <ol style="margin: 10px 0; padding-left: 20px; line-height: 1.6;">
                        <li><strong>Inicia:</strong> El micrófono se activa automáticamente</li>
                        <li><strong>Habla:</strong> Di tu mensaje normalmente</li>
                        <li><strong>Pausa:</strong> Espera 0.75 segundos en silencio</li>
                        <li><strong>Escucha:</strong> La IA responderá con voz natural</li>
                        <li><strong>Continúa:</strong> El micrófono se reactiva para seguir</li>
                    </ol>
                    <p style="margin-bottom: 0; font-size: 14px; opacity: 0.9;">
                        💡 <em>Tip: Habla con naturalidad, la IA detectará automáticamente cuando termines.</em>
                    </p>
                </div>
                """)
                
            with gr.Column(scale=2):
                gr.HTML("""
                <div style="background: #f8f9fa; padding: 15px; border-radius: 10px; margin-bottom: 15px;">
                    <h3 style="margin-top: 0; color: #495057;">💬 Conversación</h3>
                </div>
                """)
                
                chatbot = gr.Chatbot(
                    label="Historial de Conversación",
                    type="messages",
                    height=350,
                    show_copy_button=True,
                    render_markdown=True,
                    show_label=False,
                    avatar_images=(None, "https://openai.com/favicon.ico")
                )
                
                output_audio = gr.Audio(
                    label="🔊 Respuesta",
                    streaming=True,
                    autoplay=True,
                    show_download_button=True,
                    show_share_button=False
                )
        
        # Estado de la aplicación
        state = gr.State(value=AppState())
        
        # Configurar eventos de audio streaming
        
        # Stream de audio de entrada (procesa cada 0.5 segundos)
        stream_event = input_audio.stream(
            process_audio,
            inputs=[input_audio, state],
            outputs=[input_audio, state],
            stream_every=0.5,  # Procesar cada medio segundo
            time_limit=30,     # Límite de 30 segundos por grabación
        )
        
        # Generar respuesta cuando se detiene la grabación
        respond_event = input_audio.stop_recording(
            response,
            inputs=[state],
            outputs=[output_audio, state]
        )
        
        # Actualizar chatbot con la conversación
        respond_event.then(
            lambda s: s.conversation,
            inputs=[state],
            outputs=[chatbot]
        )
        
        # Reiniciar grabación automáticamente cuando termina el audio de salida
        restart_event = output_audio.stop(
            start_recording_user,
            inputs=[state],
            outputs=[input_audio]
        )
        
        # Botón para detener conversación
        stop_btn.click(
            stop_conversation,
            outputs=[state, input_audio],
            cancels=[respond_event, restart_event]
        )
        
        # Botón para limpiar historial
        clear_btn.click(
            reset_conversation,
            outputs=[state, chatbot]
        )
        
        # Mostrar estado de configuración
        api_key_status = "✅ Configurada correctamente" if os.getenv("OPENAI_API_KEY") else "❌ No encontrada"
        status_color = "#98ab9d" if os.getenv("OPENAI_API_KEY") else "#f8d7da"
        
        gr.HTML(f"""
        <div style="margin-top: 20px; padding: 15px; background-color: {status_color}; border-radius: 10px; border-left: 4px solid {'#28a745' if os.getenv('OPENAI_API_KEY') else '#dc3545'};">
            <h4 style="margin-top: 0;">🔑 Estado de Configuración</h4>
            <p><strong>API Key OpenAI:</strong> {api_key_status}</p>
            <p><strong>Modelo:</strong> GPT-4o mini Audio Preview</p>
            <p><strong>Funciones:</strong> Audio entrada/salida, Streaming, Detección de pausas</p>
            {'' if os.getenv("OPENAI_API_KEY") else '<p style="color: #721c24; margin-bottom: 0;"><strong>⚠️ Para usar la aplicación:</strong><br>1. Obtén tu API key en <a href="https://platform.openai.com/api-keys" target="_blank">OpenAI Platform</a><br>2. Configúrala: <code>export OPENAI_API_KEY="tu-api-key"</code><br>3. Reinicia la aplicación</p>'}
        </div>
        """)
    
    return demo

if __name__ == "__main__":
    # Verificar configuración al inicio
    print("🚀 Iniciando Agente de Cobranza Telefónica...")
    print("=" * 50)
    
    if not os.getenv("OPENAI_API_KEY"):
        print("⚠️  ADVERTENCIA: Variable de entorno OPENAI_API_KEY no configurada")
    else:
        print("✅ API Key de OpenAI configurada correctamente")
        print("✅ Modelo: GPT-4o mini Audio Preview")
        print("✅ Funciones: Streaming de audio bidireccional")
        print()
    
    print("🌐 Iniciando servidor Gradio...")
    demo = create_voice_chatbot()
    demo.queue()  # Habilitar cola para manejo de múltiples usuarios
    demo.launch(
        server_name="0.0.0.0",     # Accesible desde cualquier IP
        server_port=7860,          # Puerto estándar
        share=False,                # Cambiar a True para URL pública
        show_error=False,          # Mostrar errores detallados
        debug=False,               # Cambiar a True para modo debug
        quiet=False                # Mostrar logs
    )