Update app.py

app.py

@@ -1,372 +1,306 @@
-import os
-from dotenv import load_dotenv
-from supabase import create_client, Client
 import streamlit as st
+import openai
+from dotenv import load_dotenv
+import nltk
+import os
+import tempfile
+from nltk.tokenize import word_tokenize
+from nltk.corpus import stopwords
+from nltk.stem import SnowballStemmer
+import PyPDF2
+import time
+from google.cloud import texttospeech
+from streamlit_webrtc import webrtc_streamer, WebRtcMode, AudioProcessorBase
+from Historial.historial_chat import cargar_historial, guardar_historial
+from agent_functions import menu_df, tomar_pedido_agente, procesar_orden_agente, generar_pdf_orden, obtener_respuesta, generar_mensaje_automatico
 
-# Cargar las claves API desde el archivo .env
+# Configuración de NLTK
+nltk.download('punkt')
+nltk.download('stopwords')
+
+# Cargar la clave API desde el archivo .env
 load_dotenv()
-supabase_url = os.getenv("SUPABASE_URL")
-supabase_key = os.getenv("SUPABASE_KEY")
-
-# Crear el cliente de Supabase
-supabase: Client = create_client(supabase_url, supabase_key)
-
-def obtener_datos():
-    response = supabase.table('tu_tabla').select('*').execute()
-    if response.status_code == 200:
-        return response.data
-    else:
-        st.error(f"Error al obtener datos: {response.error.message}")
-        return []
-
-def insertar_datos(datos):
-    response = supabase.table('tu_tabla').insert(datos).execute()
-    if response.status_code == 201:
-        st.success("Datos insertados con éxito.")
-    else:
-        st.error(f"Error al insertar datos: {response.error.message}")
-
-def supabase_page():
-    st.title("Acceso a Base de Datos en la Nube con Supabase")
-
-    # Mostrar datos
-    if st.button("Obtener Datos"):
-        datos = obtener_datos()
-        if datos:
-            st.write(datos)
-
-    # Insertar datos
-    with st.form("insertar_datos_form"):
-        columna1 = st.text_input("Valor para columna1")
-        columna2 = st.text_input("Valor para columna2")
-        submitted = st.form_submit_button("Insertar Datos")
-        if submitted:
-            datos = {
-                "columna1": columna1,
-                "columna2": columna2
-            }
-            insertar_datos(datos)
+os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "botidinamix-g.json"
+openai.api_key = os.getenv("OPENAI_API_KEY")
 
-def main():
-    st.set_page_config(page_title="Galatea OMARDENT", layout="wide")
-
-    # Inicializar el estado de la sesión
-    if 'modelo' not in st.session_state:
-        st.session_state['modelo'] = "gpt-3.5-turbo"
-    if 'temperatura' not in st.session_state:
-        st.session_state['temperatura'] = 0.5
-    if 'mensajes_chat' not in st.session_state:
-        st.session_state['mensajes_chat'] = []
-    if 'transcripcion_voz' not in st.session_state:
-        st.session_state['transcripcion_voz'] = ""
-    if 'imagen_asistente' not in st.session_state:
-        st.session_state['imagen_asistente'] = None
-    if 'video_estado' not in st.session_state:
-        st.session_state['video_estado'] = 'paused'
-    if 'assistant_id' not in st.session_state:
-        st.session_state['assistant_id'] = 'asst_4ZYvBvf4IUVQPjnugSZGLdV2'
-    if 'presupuesto_texto' not in st.session_state:
-        st.session_state['presupuesto_texto'] = ''
-    if 'mostrar_chat' not in st.session_state:
-        st.session_state['mostrar_chat'] = False
-
-    # Barra lateral
-    ruta_logo = os.path.join("assets", "Logo Omardent.png")
-    if os.path.exists(ruta_logo):
-        st.sidebar.image(ruta_logo, use_column_width=True)
-    else:
-        st.sidebar.warning(f"Error: No se pudo encontrar la imagen en la ruta: {ruta_logo}")
-
-    st.sidebar.title("🤖 Galatea OMARDENT")
-    st.sidebar.markdown("---")
-    st.sidebar.subheader("🧠 Configuración del Modelo")
-    st.session_state['modelo'] = st.sidebar.selectbox(
-        "Selecciona el modelo:",
-        ["gpt-3.5-turbo", "gpt-4", "gpt-4-32k", "gpt-4o"],
-        index=0,
-        key='modelo_selectbox',  # Clave única
-        help="Elige el modelo de lenguaje de OpenAI que prefieras."
-    )
-    st.sidebar.markdown("---")
-    st.session_state['temperatura'] = st.sidebar.slider(
-        "🌡️ Temperatura",
-        min_value=0.0, max_value=1.0,
-        value=st.session_state['temperatura'],
-        step=0.1,
-        key='temperatura_slider'  # Clave única
-    )
-    assistant_id = st.sidebar.text_input("Assistant ID", key="assistant_id", help="Introduce el Assistant ID del playground de OpenAI")
-    
-    st.sidebar.markdown("---")
-    st.sidebar.subheader("🌟 Navegación")
-    lateral_page = st.sidebar.radio("Ir a", ["Página Principal", "Gestión de Trabajos", "Gestión de Insumos", "Registro de Radiografías", "Buscar Datos", "Notificaciones", "Recomendaciones", "Asistente de Presupuestos", "Comunicación", "Asistente de Agendamiento", "Supabase"])
-
-    top_page = st.selectbox("Navegación Superior", ["Página Principal", "Galatea-Asistente"])
-
-    if top_page == "Galatea-Asistente":
-        mostrar_galatea_asistente()
-    else:
-        if lateral_page == "Página Principal":
-            mostrar_pagina_principal()
-        elif lateral_page == "Gestión de Trabajos":
-            flujo_laboratorio()
-        elif lateral_page == "Gestión de Insumos":
-            flujo_insumos()
-        elif lateral_page == "Registro de Radiografías":
-            flujo_radiografias()
-        elif lateral_page == "Buscar Datos":
-            buscar_datos_guardados()
-        elif lateral_page == "Notificaciones":
-            generar_notificaciones_pendientes()
-        elif lateral_page == "Recomendaciones":
-            mostrar_recomendaciones()
-        elif lateral_page == "Asistente de Presupuestos":
-            flujo_presupuestos()
-        elif lateral_page == "Comunicación":
-            st.write("Página de Comunicación")  # Implementar según sea necesario
-        elif lateral_page == "Asistente de Agendamiento":
-            st.write("Página de Agendamiento")  # Implementar según sea necesario
-        elif lateral_page == "Supabase":
-            supabase_page()
-
-def mostrar_pagina_principal():
-    st.title("VIRTUAL OMARDENT AI-BOTIDINAMIX")
-    st.markdown(
-        f"""
-        <style>
-        #video-container {{
-            position: relative;
-            width: 100%;
-            padding-bottom: 56.25%;
-            background-color: lightblue;
-            overflow: hidden;
-        }}
-        #background-video {{
-            position: absolute;
-            top: 0;
-            left: 0;
-            width: 100%;
-            height: 100%;
-        }}
-        </style>
-        <div id="video-container">
-            <video id="background-video" autoplay loop muted playsinline>
-                <source src="https://cdn.leonardo.ai/users/645c3d5c-ca1b-4ce8-aefa-a091494e0d09/generations/0c4f0fe7-5937-4644-b984-bdbd95018990/0c4f0fe7-5937-4644-b984-bdbd95018990.mp4" type="video/mp4">
-            </video>
-        </div>
-        """,
-        unsafe_allow_html=True
-    )
+# Función para extraer texto del PDF
+def extraer_texto_pdf(archivo):
+    texto = ""
+    if archivo:
+        with tempfile.NamedTemporaryFile(delete=False) as temp_file:
+            temp_file.write(archivo.read())
+            temp_file_path = temp_file.name
+        with open(temp_file_path, 'rb') as file:
+            reader = PyPDF2.PdfReader(file)
+            for page in range(len(reader.pages)):
+                texto += reader.pages[page].extract_text()
+        os.unlink(temp_file_path)
+    return texto
 
-    archivo_pdf = st.file_uploader("📂 Cargar PDF", type='pdf', key='chat_pdf')
+# Función para preprocesar texto
+def preprocesar_texto(texto):
+    tokens = word_tokenize(texto, language='spanish')
+    tokens = [word.lower() for word in tokens if word.isalpha()]
+    stopwords_es = set(stopwords.words('spanish'))
+    tokens = [word for word in tokens if word not in stopwords_es]
+    stemmer = SnowballStemmer('spanish')
+    tokens = [stemmer.stem(word) for word in tokens]
+    return " ".join(tokens)
 
-    col1, col2 = st.columns([3, 1])
-    with col1:
-        pregunta_usuario = st.text_input("Pregunta:", key='unique_chat_input_key', value=st.session_state['transcripcion_voz'])
-    with col2:
-        capturar_voz()
-    
-    if pregunta_usuario:
-        manejar_pregunta_usuario(pregunta_usuario, archivo_pdf)
+# Clase para procesar audio
+class AudioProcessor(AudioProcessorBase):
+    def __init__(self):
+        self.audio_bytes = b''
 
-def mostrar_galatea_asistente():
+    def recv(self, frame):
+        self.audio_bytes += frame.to_ndarray().tobytes()
+        return frame
+
+# Main App
+def main():
+    # --- Diseño general ---
+    st.set_page_config(page_title="Asistente Virtual", page_icon="🤖")
+
+    # --- Estilos CSS personalizados ---
     st.markdown(
         """
         <style>
-        #video-container {
-            position: relative;
-            width: 100%;
-            height: 40vh;
-            background-color: lightblue;
-            overflow: hidden;
-            display: flex;
-            justify-content: center;
-            align-items: center;
-        }
-        #background-video {
-            width: 100%;
-            height: auto;
-        }
-        #chat-container {
-            margin-top: 20px;
-            width: 100%;
-            display: flex;
-            flex-direction: column;
-            justify-content: center;
-            align-items: center;
-        }
-        .chat-message {
-            background: rgba(255, 255, 255, 0.8);
-            border-radius: 10px;
-            padding: 10px;
-            margin-bottom: 10px;
-            max-width: 70%;
-        }
-        .chat-message.user {
-            align-self: flex-start;
-        }
-        .chat-message.assistant {
-            align-self: flex-end;
-            background: rgba(0, 123, 255, 0.8);
-            color: white;
-        }
+            body {
+                background: rgb(241,241,234);
+                background: radial-gradient(circle, rgba(241,241,234,1) 4%, rgba(255,127,8,1) 36%, rgba(235,255,8,1) 94%, rgba(0,0,255,1) 99%);
+            }
+            h1, h2, h3, h4, h5, h6 {
+                color: green !important;
+                font-weight: bold !important;
+            }
+            .stChatFloatingInputContainer {
+                background-color: rgba(255, 255, 255, 0.8);
+                border-radius: 10px;
+            }
+            .stTextInput > div > div > input {
+                color: #333;
+            }
+            [data-testid="stChatMessage"] {
+                background-color: black !important;
+                color: gold !important;
+                border-radius: 10px;
+            }
+            [data-testid="stChatMessage"] p {
+                color: gold !important;
+            }
+            ::-webkit-scrollbar {
+                width: 16px;
+            }
+            ::-webkit-scrollbar-thumb {
+                background-color: #FFD700;
+                border-radius: 10px;
+            }
+            .st-spinner > div {
+                border-top-color: transparent;
+                border-right-color: transparent;
+                animation: spin 1s linear infinite;
+            }
+            @keyframes spin {
+                from { transform: rotate(0deg); }
+                to { transform: rotate(360deg); }
+            }
         </style>
-        <div id="video-container">
-            <video id="background-video" autoplay loop muted playsinline>
-                <source src="https://cdn.leonardo.ai/users/645c3d5c-ca1b-4ce8-aefa-a091494e0d09/generations/aaa569a1-8952-4e8e-9c3c-71cc66e62f04/aaa569a1-8952-4e8e-9c3c-71cc66e62f04.mp4" type="video/mp4">
-            </video>
-        </div>
-        <div id="chat-container">
         """,
-        unsafe_allow_html=True
+        unsafe_allow_html=True,
     )
 
-    for mensaje in st.session_state['mensajes_chat']:
-        clase = "user" if mensaje["role"] == "user" else "assistant"
-        st.markdown(f'<div class="chat-message {clase}">{mensaje["content"]}</div>', unsafe_allow_html=True)
+    # --- Barra lateral ---
+    with st.sidebar:
+        st.image("hamburguesa napolitana.jpg")
+        st.title("🤖 RESTAURANTE SAZON BURGER 🍔✨-BOTIDINAMIX AI")
+        st.markdown("---")
+
+        # Opciones de navegación
+        pagina = st.selectbox("Selecciona una página", ["Chat", "Subir PDF", "Agentes"])
+
+    # --- Página principal ---
+    if pagina == "Chat":
+        mostrar_chat()
+    elif pagina == "Subir PDF":
+        mostrar_subir_pdf()
+    elif pagina == "Agentes":
+        mostrar_agentes()
+
+def mostrar_chat():
+    # --- Botones de historial ---
+    if st.button("Buscar Historial"):
+        st.session_state.mostrar_historial = True
+    if st.button("Borrar Historial"):
+        st.session_state.mensajes = []
+        st.session_state.mostrar_historial = False
+        st.success("Historial borrado correctamente")
+
+    # --- Chatbot ---
+    if 'mensajes' not in st.session_state:
+        st.session_state.mensajes = cargar_historial()
 
-    pregunta_usuario = st.text_input("Escribe tu pregunta aquí:", key='unique_chat_input_key', value=st.session_state['transcripcion_voz'])
-    if st.button("Enviar Pregunta"):
-        manejar_pregunta_usuario(pregunta_usuario)
+    for mensaje in st.session_state.mensajes:
+        with st.chat_message(mensaje["role"]):
+            st.markdown(mensaje["content"])
 
-    st.markdown("</div>", unsafe_allow_html=True)
+    # Función para manejar la entrada de audio
+    def on_audio(audio_bytes):
+        with st.spinner("Transcribiendo..."):
+            transcript = openai.Audio.transcribe("whisper-1", audio_bytes)
+            pregunta_usuario = transcript["text"]
+            st.session_state.mensajes.append({"role": "user", "content": pregunta_usuario, "timestamp": time.time()})
+            with st.chat_message("user"):
+                st.markdown(pregunta_usuario)
 
-    if st.session_state['imagen_asistente']:
-        st.image(st.session_state['imagen_asistente'], use_column_width=True)
-    else:
-        st.warning("No se ha cargado ninguna imagen. Por favor, carga una imagen en la página principal.")
+    st.subheader("🎤 Captura de voz")
+    st.info("Haz clic en el micrófono y comienza a hablar. Tu pregunta se transcribirá automáticamente.")
+    with st.container():
+        if st.button("Grabar 🎙️"):
+            st.session_state.run_webrtc = True
+        if st.session_state.get("run_webrtc", False):
+            webrtc_ctx = webrtc_streamer(
+                key="example",
+                mode=WebRtcMode.SENDONLY,
+                audio_receiver_size=256,
+                rtc_configuration={
+                    "iceServers": [{"urls": ["stun:stun.l.google.com:19302"]}]
+                },
+                media_stream_constraints={"audio": True},
+                audio_processor_factory=AudioProcessor,
+            )
 
-def manejar_pregunta_usuario(pregunta_usuario, archivo_pdf=None):
-    st.session_state['mensajes_chat'].append({"role": "user", "content": pregunta_usuario})
-    with st.chat_message("user"):
-        st.markdown(pregunta_usuario)
+            if webrtc_ctx.audio_receiver:
+                audio_frames = webrtc_ctx.audio_receiver.get_frames(timeout=1)
+                for audio_frame in audio_frames:
+                    audio_bytes = audio_frame.to_ndarray().tobytes()
+                    on_audio(audio_bytes)
 
-    texto_preprocesado = ""
+    st.markdown("---")
+    st.subheader("📄 Subir PDF")
+    st.info("Sube un archivo PDF y el asistente responderá en función de su contenido.")
+    archivo_pdf = st.file_uploader("Selecciona un archivo PDF", type=["pdf"])
+
+    texto_extraido = ""
     if archivo_pdf:
-        texto_pdf = extraer_texto_pdf(archivo_pdf)
-        texto_preprocesado = preprocesar_texto(texto_pdf)
-    else:
-        with open("assets/instrucciones.pdf", "rb") as file:
-            texto_pdf = extraer_texto_pdf(file)
-            texto_preprocesado = preprocesar_texto(texto_pdf)
-
-    # Obtener respuesta del modelo usando Assistant ID si está presente
-    assistant_id = st.session_state.get('assistant_id', '')
-    if assistant_id:
-        prompt = f"{texto_preprocesado}\n\n{pregunta_usuario}"
-        response = openai.ChatCompletion.create(
-            model=st.session_state['modelo'],
-            messages=[
-                {"role": "system", "content": "You are a helpful assistant."},
-                {"role": "user", "content": prompt}
-            ],
-            temperature=st.session_state['temperatura'],
-            user=assistant_id
-        )
-        respuesta = response.choices[0].message['content'].strip()
-    else:
-        respuesta = obtener_respuesta(
-            pregunta_usuario,
-            texto_preprocesado,
-            st.session_state['modelo'],
-            st.session_state['temperatura'],
-            assistant_id
-        )
-    
-    st.session_state['mensajes_chat'].append({"role": "assistant", "content": respuesta})
-    with st.chat_message("assistant"):
-        st.markdown(respuesta)
-
-    # Convertir la respuesta en voz
-    client = texttospeech.TextToSpeechClient()
-    synthesis_input = texttospeech.SynthesisInput(text=respuesta)
-    voice = texttospeech.VoiceSelectionParams(language_code="es-ES", ssml_gender=texttospeech.SsmlVoiceGender.FEMALE)
-    audio_config = texttospeech.AudioConfig(audio_encoding=texttospeech.AudioEncoding.MP3)
-    response = client.synthesize_speech(input=synthesis_input, voice=voice, audio_config=audio_config)
-    
-    with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_file:
-        tmp_file.write(response.audio_content)
-        audio_file_path = tmp_file.name
-
-    # Incrustar el audio en la página y reproducirlo automáticamente
-    audio_html = f"""
-    <audio id="response-audio" src="data:audio/mp3;base64,{base64.b64encode(response.audio_content).decode()}" autoplay></audio>
-    <script>
-    document.getElementById('response-audio').onended = function() {{
-        document.getElementById('background-video').pause();
-    }};
-    </script>
-    """
-    st.markdown(audio_html, unsafe_allow_html=True)
-
-    # Reproducir el video solo cuando el chat está activo
-    st.session_state['video_estado'] = 'playing'
-    st.markdown(f"<script>document.getElementById('background-video').play();</script>", unsafe_allow_html=True)
-
-def capturar_voz():
-    st.markdown(
-        """
-        <style>
-        .assistant-button {
-            display: flex;
-            align-items: center;
-            justify-content: center;
-            background-color: #4CAF50;
-            color: white;
-            padding: 10px;
-            border: none;
-            border-radius: 5px;
-            cursor: pointer;
-            font-size: 16px;
-            margin-top: 10px;
-        }
-        .assistant-button img {
-            margin-right: 10px;
-        }
-        </style>
-        <button class="assistant-button" onclick="startRecording()">
-            <img src='https://img2.gratispng.com/20180808/cxq/kisspng-robotics-science-computer-icons-robot-technology-robo-to-logo-svg-png-icon-free-download-45527-5b6baa46a5e322.4713113715337825986795.jpg' alt='icon' width='20' height='20'/>
-            Capturar Voz
-        </button>
-        <script>
-            function startRecording() {
-                const recognition = new (window.SpeechRecognition || window.webkitSpeechRecognition)();
-                recognition.lang = 'es-ES';
-                recognition.interimResults = false;
-                recognition.maxAlternatives = 1;
-                recognition.start();
-                recognition.onresult = (event) => {
-                    const lastResult = event.results.length - 1;
-                    const text = event.results[lastResult][0].transcript;
-                    const customEvent = new CustomEvent('audioTranscription', { detail: text });
-                    document.dispatchEvent(customEvent);
-                };
-                recognition.onspeechend = () => {
-                    recognition.stop();
-                };
-                recognition.onerror = (event) => {
-                    console.error(event.error);
-                };
-            }
-            document.addEventListener('audioTranscription', (event) => {
-                const transcription = event.detail;
-                document.querySelector("input[name='unique_chat_input_key']").value = transcription;
-                // También puedes actualizar el estado de Streamlit aquí si es necesario
-                fetch('/process_audio', {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json'
-                    },
-                    body: JSON.stringify({ transcription })
-                }).then(response => response.json())
-                  .then(data => {
-                      // Manejo de la respuesta de Flask si es necesario
-                  });
-            });
-        </script>
-        """,
-        unsafe_allow_html=True
-    )
+        texto_extraido = extraer_texto_pdf(archivo_pdf)
+        st.success("Texto extraído del PDF exitosamente.")
+        st.text_area("Texto extraído", value=texto_extraido, height=200)
+
+    if not texto_extraido:
+        texto_extraido = st.text_area("Texto extraído", height=200)
+
+    texto_preprocesado = preprocesar_texto(texto_extraido)
+
+    # --- Opciones de entrada de usuario ---
+    st.markdown("---")
+    pregunta_usuario = st.text_input("Escribe tu pregunta:")
+    if st.button("Enviar"):
+        if pregunta_usuario:
+            st.session_state.mensajes.append({"role": "user", "content": pregunta_usuario, "timestamp": time.time()})
+            with st.chat_message("user"):
+                st.markdown(pregunta_usuario)
+
+            with st.spinner("Generando respuesta..."):
+                respuesta, audio_path = obtener_respuesta(pregunta_usuario, texto_preprocesado, modelo="gpt-4", temperatura=0.5)
+                st.session_state.mensajes.append({"role": "assistant", "content": respuesta, "timestamp": time.time()})
+                with st.chat_message("assistant"):
+                    st.markdown(respuesta)
+                st.audio(audio_path, format="audio/mp3", start_time=0)
+
+            guardar_historial(st.session_state.mensajes)
+        else:
+            st.warning("Por favor, ingresa una pregunta antes de enviar.")
+
+def mostrar_subir_pdf():
+    st.subheader("📄 Subir PDF")
+    st.info("Sube un archivo PDF y el asistente responderá en función de su contenido.")
+    archivo_pdf = st.file_uploader("Selecciona un archivo PDF", type=["pdf"])
+
+    texto_extraido = ""
+    if archivo_pdf:
+        texto_extraido = extraer_texto_pdf(archivo_pdf)
+        st.success("Texto extraído del PDF exitosamente.")
+        st.text_area("Texto extraído", value=texto_extraido, height=200)
+
+    if not texto_extraido:
+        texto_extraido = st.text_area("Texto extraído", height=200)
+
+    texto_preprocesado = preprocesar_texto(texto_extraido)
+
+    # --- Opciones de entrada de usuario ---
+    st.markdown("---")
+    pregunta_usuario = st.text_input("Escribe tu pregunta:")
+    if st.button("Enviar"):
+        if pregunta_usuario:
+            st.session_state.mensajes.append({"role": "user", "content": pregunta_usuario, "timestamp": time.time()})
+            with st.chat_message("user"):
+                st.markdown(pregunta_usuario)
+
+            with st.spinner("Generando respuesta..."):
+                respuesta, audio_path = obtener_respuesta(pregunta_usuario, texto_preprocesado, modelo="gpt-4", temperatura=0.5)
+                st.session_state.mensajes.append({"role": "assistant", "content": respuesta, "timestamp": time.time()})
+                with st.chat_message("assistant"):
+                    st.markdown(respuesta)
+                st.audio(audio_path, format="audio/mp3", start_time=0)
+
+            guardar_historial(st.session_state.mensajes)
+        else:
+            st.warning("Por favor, ingresa una pregunta antes de enviar.")
+
+def mostrar_agentes():
+    st.subheader("📋 Menú y Pedidos")
+    st.success("Menú cargado exitosamente. Listo para tomar pedidos.")
+    st.write(menu_df)
+
+    # Captura de pedido
+    st.markdown("Selecciona los items del menú:")
+    items_seleccionados = st.multiselect("Items", menu_df['item'].tolist())
+
+    if st.button("Tomar Pedido"):
+        if items_seleccionados:
+            pedido_usuario = ','.join(items_seleccionados)
+            confirmados = tomar_pedido_agente(pedido_usuario)
+            st.info(f"Pedido confirmado: {confirmados}")
+
+            total = procesar_orden_agente(','.join(confirmados))
+            st.success(f"Total del pedido: ${total}")
+
+            # Generar PDF de la orden
+            order_details = {item: {'price': menu_df[menu_df['item'] == item]['price'].values[0]} for item in confirmados}
+            pdf_path = generar_pdf_orden(order_details)
+            st.markdown(f"[Descargar PDF de la Orden]({pdf_path})", unsafe_allow_html=True)
+
+            # Generar mensaje automático
+            mensaje_automatico = generar_mensaje_automatico(confirmados)
+            st.session_state.mensajes_agente.append({"role": "assistant", "content": mensaje_automatico, "timestamp": time.time()})
+            with st.chat_message("assistant"):
+                st.markdown(mensaje_automatico)
+
+    # --- Chat para Agentes ---
+    st.subheader("Chat con Agentes")
+    if 'mensajes_agente' not in st.session_state:
+        st.session_state.mensajes_agente = []
+
+    for mensaje in st.session_state.mensajes_agente:
+        with st.chat_message(mensaje["role"]):
+            st.markdown(mensaje["content"])
+
+    agente_pregunta = st.text_input("Escribe tu pregunta para el agente:")
+    if st.button("Enviar al Agente"):
+        if agente_pregunta:
+            st.session_state.mensajes_agente.append({"role": "user", "content": agente_pregunta, "timestamp": time.time()})
+            with st.chat_message("user"):
+                st.markdown(agente_pregunta)
+
+            # Procesar la respuesta del agente
+            with st.spinner("El agente está respondiendo..."):
+                respuesta_agente, audio_path = obtener_respuesta(agente_pregunta, '', modelo="gpt-4", temperatura=0.5)
+                st.session_state.mensajes_agente.append({"role": "assistant", "content": respuesta_agente, "timestamp": time.time()})
+                with st.chat_message("assistant"):
+                    st.markdown(respuesta_agente)
+                st.audio(audio_path, format="audio/mp3", start_time=0)
+        else:
+            st.warning("Por favor, ingresa una pregunta antes de enviar.")
 
 if __name__ == "__main__":
     main()