Add files via upload

.gitattributes

@@ -0,0 +1,36 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+docs/gemini-chatbot.gif filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -0,0 +1,11 @@
+---
+license: mit
+title: Chatbot_Email
+sdk: streamlit
+emoji: 🏆
+colorFrom: red
+colorTo: yellow
+pinned: true
+sdk_version: 1.45.0
+short_description: Write email with AI
+---

app.py

@@ -0,0 +1,384 @@
+import time
+import os
+import uuid
+import traceback
+import joblib
+import streamlit as st
+from dotenv import load_dotenv
+from streamlit.runtime.scriptrunner import get_script_run_ctx
+from system_prompts import get_unified_email_prompt
+from session_state import (
+    SessionState,
+    DEFAULT_GEMINI_MODEL,
+    DATA_DIR,
+)
+
+# Inicializar el estado de la sesión
+state = SessionState()
+STREAM_SETTINGS = {'batch_size': 1, 'delay_seconds': 0.01}
+user_past_chats_list_path = None
+
+def get_user_namespace():
+    """
+    Obtiene un namespace para persistencia.
+    - Si CHATBOT_USER_NAMESPACE está definido, se usa ese valor (recomendado para app de un solo usuario).
+    - Si MULTI_USER_MODE=true, usa session_id para aislar por sesión.
+    - Caso contrario, usa un user_id persistente en query params para aislar por usuario y sobrevivir reinicios.
+    """
+    configured_namespace = os.environ.get('CHATBOT_USER_NAMESPACE')
+    if configured_namespace:
+        return configured_namespace
+
+    is_multi_user_mode = os.environ.get('MULTI_USER_MODE', 'false').strip().lower() == 'true'
+    if is_multi_user_mode:
+        context = get_script_run_ctx()
+        if context and getattr(context, 'session_id', None):
+            return context.session_id
+
+    user_id = st.query_params.get('uid')
+    if not user_id:
+        user_id = uuid.uuid4().hex
+        st.query_params['uid'] = user_id
+    return f'user_{user_id}'
+
+# Función para detectar saludos y generar respuestas personalizadas
+def is_greeting(text):
+    """Detecta si el texto es un saludo simple"""
+    text = text.lower().strip()
+    greetings = ['hola', 'hey', 'saludos', 'buenos días', 'buenas tardes', 'buenas noches', 'hi', 'hello']
+    
+    # Solo considerar como saludo si es el primer mensaje del usuario
+    # y es un saludo simple
+    is_simple_greeting = any(greeting in text for greeting in greetings) and len(text.split()) < 4
+    return is_simple_greeting and len(state.messages) == 0
+
+# Función para procesar mensajes (unifica la lógica de procesamiento)
+def process_message(prompt, is_example=False):
+    """Procesa un mensaje del usuario, ya sea directo o de un ejemplo"""
+    handle_chat_title(prompt)
+    
+    with st.chat_message('user', avatar=USER_AVATAR_ICON):
+        st.markdown(prompt)
+    
+    state.add_message('user', prompt, USER_AVATAR_ICON)
+    
+    # Obtener el prompt mejorado primero
+    enhanced_prompt = get_enhanced_prompt(prompt, is_example)
+    
+    # Mover la respuesta del modelo después del mensaje del usuario
+    with st.chat_message(MODEL_ROLE, avatar=AI_AVATAR_ICON):
+        try:
+            message_placeholder = st.empty()
+            typing_indicator = st.empty()
+            typing_indicator.markdown("*Generando respuesta...*")
+            
+            response = state.send_message(enhanced_prompt)
+            full_response = stream_response(response, message_placeholder, typing_indicator, STREAM_SETTINGS)
+            
+            if full_response:
+                state.add_message(MODEL_ROLE, full_response, AI_AVATAR_ICON)
+                if hasattr(state.chat, 'get_history'):
+                    state.gemini_history = state.chat.get_history()
+                else:
+                    state.gemini_history = getattr(state.chat, 'history', [])
+                state.save_chat_history()
+                
+        except Exception as e:
+            show_detailed_error("process_message", e)
+            return
+
+def show_detailed_error(context, error):
+    """Muestra errores con contexto y traza para facilitar debug en producción."""
+    st.error(f"Ocurrió un error en {context}. Intenta de nuevo.")
+    with st.expander("Ver detalles técnicos del error"):
+        st.code(f"{type(error).__name__}: {error}\n\n{traceback.format_exc()}")
+
+def handle_chat_title(prompt):
+    """Maneja la lógica del título del chat"""
+    if state.chat_id not in past_chats:
+        temp_title = f'SesiónChat-{state.chat_id}'
+        generated_title = state.generate_chat_title(prompt)
+        state.chat_title = generated_title or temp_title
+        past_chats[state.chat_id] = state.chat_title
+    else:
+        state.chat_title = past_chats[state.chat_id]
+    joblib.dump(past_chats, user_past_chats_list_path)
+
+def get_enhanced_prompt(prompt, is_example):
+    """Genera el prompt mejorado según el tipo de mensaje"""
+    if is_greeting(prompt):
+        return (
+            "Responde ÚNICAMENTE con esta frase, sin agregar nada más: "
+            "\"¡Perfecto! Empecemos por la primera: "
+            "¿Quién es tu audiencia ideal para este correo? "
+            "Descríbela con detalle (contexto, problema principal, deseo y nivel de conciencia).\""
+        )
+    elif is_example:
+        return (
+            f"El usuario seleccionó esta pregunta del menú: '{prompt}'. "
+            "Respóndela de forma directa, útil y conversacional, con ejemplos concretos. "
+            "Después de responder, invita al usuario a iniciar el flujo de 5 preguntas en este orden: audiencia, producto, nombre, CTA y ángulo."
+        )
+    return prompt
+
+def stream_response(response, message_placeholder, typing_indicator, stream_settings):
+    """Maneja el streaming de la respuesta"""
+    full_response = ''
+    batch_size = max(1, int(stream_settings.get('batch_size', 24)))
+    delay_seconds = max(0.0, float(stream_settings.get('delay_seconds', 0.0)))
+    pending_chars = 0
+
+    try:
+        for chunk in response:
+            if chunk.text:
+                for ch in chunk.text:
+                    full_response += ch
+                    pending_chars += 1
+                    if pending_chars >= batch_size:
+                        if delay_seconds:
+                            time.sleep(delay_seconds)
+                        message_placeholder.markdown(full_response + '▌')
+                        pending_chars = 0
+    except Exception as e:
+        show_detailed_error("stream_response", e)
+        return ''
+
+    if pending_chars > 0:
+        if delay_seconds:
+            time.sleep(delay_seconds)
+        message_placeholder.markdown(full_response + '▌')
+
+    typing_indicator.empty()
+    message_placeholder.markdown(full_response)
+    return full_response
+
+# Función para cargar CSS personalizado
+def load_css(file_path):
+    with open(file_path) as f:
+        st.markdown(f'<style>{f.read()}</style>', unsafe_allow_html=True)
+
+# Intentar cargar el CSS personalizado con ruta absoluta para mayor seguridad
+try:
+    css_path = os.path.join(os.path.dirname(__file__), 'static', 'css', 'style.css')
+    load_css(css_path)
+except Exception as e:
+    print(f"Error al cargar CSS: {e}")
+    # Si el archivo no existe, crear un estilo básico en línea
+    st.markdown("""
+    <style>
+    .robocopy-title {
+        color: white !important;
+        font-weight: bold;
+        font-size: clamp(2.5em, 5vw, 4em);
+        line-height: 1.2;
+    }
+    </style>
+    """, unsafe_allow_html=True)
+
+# Función de utilidad para mostrar la carátula inicial
+def display_initial_header():
+    col1, col2, col3 = st.columns([1, 2, 1])
+    with col2:
+        # Centrar la imagen
+        st.markdown("""
+            <style>
+                div.stImage {
+                    text-align: center;
+                    display: block;
+                    margin-left: auto;
+                    margin-right: auto;
+                }
+            </style>
+        """, unsafe_allow_html=True)
+        st.image("robocopy_logo.png", width=300, use_container_width=True)
+        
+        # Título con diseño responsivo (eliminado el símbolo ∞)
+        st.markdown("""
+            <div style='text-align: center; margin-top: -35px; width: 100%;'>
+                <h1 class='robocopy-title' style='width: 100%; text-align: center; color: white !important; font-size: clamp(2.5em, 5vw, 4em); line-height: 1.2;'>Email Story Creator</h1>
+            </div>
+        """, unsafe_allow_html=True)
+        
+        # Subtítulo con margen superior ajustado a -30px
+        st.markdown("""
+            <div style='text-align: center; width: 100%;'>
+                <p style='font-size: 16px; color: white; width: 100%; text-align: center; margin-top: -20px;'>By Jesús Cabrera</p>
+            </div>
+        """, unsafe_allow_html=True)
+    
+    # Descripción con fondo eliminado y margen superior ajustado a -20px
+    st.markdown("""
+        <div style='text-align: center; width: 100%;'>
+            <p style='font-size: 16px; background-color: transparent; padding: 12px; border-radius: 8px; margin-top: -20px; color: white; width: 100%; text-align: center;'>
+                ✉️ Experto en emails narrativos que conectan historias con ventas de forma natural
+            </p>
+        </div>
+    """, unsafe_allow_html=True)
+
+# Función para mostrar ejemplos de preguntas
+def display_examples():
+    ejemplos = [
+        {"texto": "Definir audiencia 🎯", "prompt": "Ayúdame a definir una audiencia concreta para este correo: dolor principal, deseo y nivel de conciencia."},
+        {"texto": "Propuesta de valor 💎", "prompt": "Convierte mi producto en una promesa clara de transformación sin listar características aburridas."},
+        {"texto": "CTA que convierte 🚀", "prompt": "Dame 3 opciones de CTA claras para este email, con baja fricción y orientadas a una sola acción."},
+        {"texto": "Asunto + gancho ✉️", "prompt": "Propón 5 asuntos y 3 ganchos de apertura para aumentar aperturas y clics de este correo."}
+    ]
+
+    # Crear los botones de ejemplo
+    cols = st.columns(4)
+    for idx, ejemplo in enumerate(ejemplos):
+        with cols[idx]:
+            if st.button(ejemplo["texto"], key=f"ejemplo_{idx}", help=ejemplo["prompt"]):
+                st.session_state.pending_example_prompt = ejemplo["prompt"]
+                st.session_state.hide_initial_menu = True
+                st.rerun()
+
+# Cargar variables de entorno
+load_dotenv()
+GOOGLE_API_KEY = os.environ.get('GOOGLE_API_KEY')
+if not GOOGLE_API_KEY:
+    st.error("Falta la variable de entorno GOOGLE_API_KEY. Configúrala para continuar.")
+    st.stop()
+
+# Configuración de la aplicación
+state.user_namespace = get_user_namespace()
+user_past_chats_list_path = f'{DATA_DIR}/{state.user_namespace}/past_chats_list'
+new_chat_id = f'{time.time()}'
+MODEL_ROLE = 'ai'
+AI_AVATAR_ICON = '🤖'  # Cambia el emoji por uno de robot para coincidir con tu logo
+USER_AVATAR_ICON = '👤'  # Añade un avatar para el usuario
+
+# Crear carpeta de datos si no existe
+os.makedirs(f'{DATA_DIR}/{state.user_namespace}', exist_ok=True)
+
+# Cargar chats anteriores
+try:
+    past_chats = joblib.load(user_past_chats_list_path)
+except (FileNotFoundError, EOFError):
+    past_chats = {}
+
+# Sidebar para seleccionar chats anteriores
+with st.sidebar:
+    st.write('# Chats Anteriores')
+
+    if state.chat_id is None:
+        state.chat_id = new_chat_id
+
+    if st.button('＋ Nuevo chat', key='new_chat_sidebar', use_container_width=True):
+        state.chat_id = new_chat_id
+        st.session_state.pending_example_prompt = None
+        st.session_state.hide_initial_menu = False
+        st.session_state.editing_chat_id = None
+        st.rerun()
+
+    st.caption('Sesiones')
+    if 'editing_chat_id' not in st.session_state:
+        st.session_state.editing_chat_id = None
+
+    def chat_sort_key(chat_id):
+        try:
+            return float(chat_id)
+        except (TypeError, ValueError):
+            return 0.0
+
+    sorted_chat_ids = sorted(past_chats.keys(), key=chat_sort_key, reverse=True)
+    for index, chat_id in enumerate(sorted_chat_ids):
+        chat_title = past_chats.get(chat_id, f'SesiónChat-{chat_id}')
+        is_active_chat = chat_id == state.chat_id
+        button_label = f'● {chat_title}' if is_active_chat else chat_title
+
+        if st.button(
+            button_label,
+            key=f'chat_session_{index}_{chat_id}',
+            use_container_width=True,
+            type='primary' if is_active_chat else 'secondary',
+        ):
+            if state.chat_id != chat_id:
+                state.chat_id = chat_id
+                st.rerun()
+
+    state.chat_title = past_chats.get(state.chat_id, f'SesiónChat-{state.chat_id}')
+
+# Cargar historial del chat
+state.load_chat_history()
+
+if 'pending_example_prompt' not in st.session_state:
+    st.session_state.pending_example_prompt = None
+
+if 'hide_initial_menu' not in st.session_state:
+    st.session_state.hide_initial_menu = False
+
+if 'active_chat_id' not in st.session_state:
+    st.session_state.active_chat_id = state.chat_id
+elif st.session_state.active_chat_id != state.chat_id:
+    st.session_state.active_chat_id = state.chat_id
+    st.session_state.pending_example_prompt = None
+    st.session_state.hide_initial_menu = state.has_messages()
+    st.session_state.editing_chat_id = None
+
+# Inicializar el modelo y el chat
+system_prompt = get_unified_email_prompt()
+if (
+    st.session_state.get('initialized_model_name') != DEFAULT_GEMINI_MODEL
+    or getattr(state, 'client', None) is None
+):
+    try:
+        state.initialize_model(DEFAULT_GEMINI_MODEL, api_key=GOOGLE_API_KEY)
+        st.session_state.initialized_model_name = DEFAULT_GEMINI_MODEL
+    except Exception as e:
+        show_detailed_error("initialize_model", e)
+        st.stop()
+
+should_reinitialize_chat = (
+    state.chat is None
+    or st.session_state.get('initialized_chat_id') != state.chat_id
+    or st.session_state.get('initialized_system_prompt') != system_prompt
+)
+if should_reinitialize_chat:
+    try:
+        state.initialize_chat(system_instruction=system_prompt)
+        st.session_state.initialized_chat_id = state.chat_id
+        st.session_state.initialized_system_prompt = system_prompt
+    except Exception as e:
+        show_detailed_error("initialize_chat", e)
+        st.stop()
+
+# Mostrar mensajes del historial
+for message in state.messages:
+    with st.chat_message(
+        name=message['role'],
+        avatar=message.get('avatar'),
+    ):
+        st.markdown(message['content'])
+
+# Capturar entrada del usuario antes de renderizar el menú inicial
+user_prompt = st.chat_input('Escribe aquí tus instrucciones')
+
+if state.has_messages():
+    st.session_state.hide_initial_menu = True
+
+# Renderizar menú inicial en un contenedor limpiable
+initial_menu_container = st.container()
+if (
+    not st.session_state.hide_initial_menu
+    and not state.has_messages()
+    and not user_prompt
+    and not st.session_state.pending_example_prompt
+):
+    with initial_menu_container:
+        display_initial_header()
+        display_examples()
+
+# Procesar entrada del usuario (oculta el menú inmediatamente)
+if user_prompt:
+    st.session_state.hide_initial_menu = True
+    initial_menu_container.empty()
+    process_message(user_prompt, is_example=False)
+    st.rerun()
+
+# Procesar ejemplo seleccionado (oculta el menú inmediatamente)
+if st.session_state.pending_example_prompt:
+    initial_menu_container.empty()
+    process_message(st.session_state.pending_example_prompt, is_example=True)
+    st.session_state.pending_example_prompt = None
+    st.rerun()

firebase_store.py

@@ -0,0 +1,82 @@
+import os
+import json
+from typing import Optional
+
+import streamlit as st
+
+try:
+    import firebase_admin
+    from firebase_admin import auth, credentials, firestore
+except Exception:  # pragma: no cover - entorno sin dependencia
+    firebase_admin = None
+    auth = None
+    credentials = None
+    firestore = None
+
+
+class FirebaseSessionStore:
+    """Persistencia de sesiones en Firebase (Fase 1 rápida)."""
+
+    def __init__(self, db):
+        self.db = db
+
+    @classmethod
+    def from_env(cls) -> Optional["FirebaseSessionStore"]:
+        if firebase_admin is None:
+            return None
+
+        service_account_json = os.environ.get("FIREBASE_SERVICE_ACCOUNT_JSON")
+        service_account_path = os.environ.get("FIREBASE_SERVICE_ACCOUNT_PATH")
+        if not service_account_json and not service_account_path:
+            return None
+
+        if not firebase_admin._apps:
+            if service_account_json:
+                cred_info = json.loads(service_account_json)
+                cred = credentials.Certificate(cred_info)
+            else:
+                cred = credentials.Certificate(service_account_path)
+            firebase_admin.initialize_app(cred)
+
+        return cls(firestore.client())
+
+    def verify_id_token(self, id_token: str) -> Optional[str]:
+        if not id_token:
+            return None
+        try:
+            decoded = auth.verify_id_token(id_token)
+            return decoded.get("uid")
+        except Exception as exc:
+            st.warning(f"No se pudo validar token Firebase: {exc}")
+            return None
+
+    def _index_ref(self, user_id: str):
+        return self.db.collection("users").document(user_id).collection("meta").document("chat_index")
+
+    def _history_ref(self, user_id: str, chat_id: str):
+        return self.db.collection("users").document(user_id).collection("chats").document(str(chat_id))
+
+    def load_chat_index(self, user_id: str) -> dict:
+        doc = self._index_ref(user_id).get()
+        if not doc.exists:
+            return {}
+        return doc.to_dict().get("past_chats", {})
+
+    def save_chat_index(self, user_id: str, past_chats: dict) -> None:
+        self._index_ref(user_id).set({"past_chats": past_chats}, merge=True)
+
+    def save_chat_history(self, user_id: str, chat_id: str, messages: list, gemini_history: list) -> None:
+        self._history_ref(user_id, chat_id).set(
+            {
+                "messages": messages,
+                "gemini_history": gemini_history,
+            },
+            merge=True,
+        )
+
+    def load_chat_history(self, user_id: str, chat_id: str):
+        doc = self._history_ref(user_id, chat_id).get()
+        if not doc.exists:
+            return None, None
+        data = doc.to_dict() or {}
+        return data.get("messages"), data.get("gemini_history")

requirements.txt

@@ -0,0 +1,4 @@
+google-genai
+streamlit
+joblib
+python-dotenv

session_state.py

@@ -0,0 +1,305 @@
+import streamlit as st
+import joblib
+import os
+from google import genai
+from google.genai import types
+
+DEFAULT_GEMINI_MODEL = 'gemini-3.1-flash-lite-preview'
+DATA_DIR = 'data'
+PAST_CHATS_LIST_PATH = f'{DATA_DIR}/past_chats_list'
+
+class SessionState:
+    """
+    Clase para gestionar el estado de la sesión de Streamlit de manera centralizada.
+    Encapsula todas las operaciones relacionadas con st.session_state.
+    """
+    
+    def __init__(self):
+        # Inicializar valores por defecto si no existen
+        if 'chat_id' not in st.session_state:
+            st.session_state.chat_id = None
+        
+        if 'chat_title' not in st.session_state:
+            st.session_state.chat_title = None
+            
+        if 'messages' not in st.session_state:
+            st.session_state.messages = []
+            
+        if 'gemini_history' not in st.session_state:
+            st.session_state.gemini_history = []
+            
+        if 'model' not in st.session_state:
+            st.session_state.model = None
+
+        if 'client' not in st.session_state:
+            st.session_state.client = None
+            
+        if 'chat' not in st.session_state:
+            st.session_state.chat = None
+            
+        if 'prompt' not in st.session_state:
+            st.session_state.prompt = None
+
+        if 'system_instruction' not in st.session_state:
+            st.session_state.system_instruction = None
+
+        if 'user_namespace' not in st.session_state:
+            st.session_state.user_namespace = 'default'
+    
+    # Getters y setters para cada propiedad
+    @property
+    def chat_id(self):
+        return st.session_state.chat_id
+    
+    @chat_id.setter
+    def chat_id(self, value):
+        st.session_state.chat_id = value
+    
+    @property
+    def chat_title(self):
+        return st.session_state.chat_title
+    
+    @chat_title.setter
+    def chat_title(self, value):
+        st.session_state.chat_title = value
+    
+    @property
+    def messages(self):
+        return st.session_state.messages
+    
+    @messages.setter
+    def messages(self, value):
+        st.session_state.messages = value
+    
+    @property
+    def gemini_history(self):
+        return st.session_state.gemini_history
+    
+    @gemini_history.setter
+    def gemini_history(self, value):
+        st.session_state.gemini_history = value
+    
+    @property
+    def model(self):
+        return st.session_state.model
+    
+    @model.setter
+    def model(self, value):
+        st.session_state.model = value
+
+    @property
+    def client(self):
+        return st.session_state.client
+
+    @client.setter
+    def client(self, value):
+        st.session_state.client = value
+    
+    @property
+    def chat(self):
+        return st.session_state.chat
+    
+    @chat.setter
+    def chat(self, value):
+        st.session_state.chat = value
+    
+    @property
+    def prompt(self):
+        return st.session_state.prompt
+    
+    @prompt.setter
+    def prompt(self, value):
+        st.session_state.prompt = value
+
+    @property
+    def system_instruction(self):
+        return st.session_state.system_instruction
+
+    @system_instruction.setter
+    def system_instruction(self, value):
+        st.session_state.system_instruction = value
+
+    @property
+    def user_namespace(self):
+        return st.session_state.user_namespace
+
+    @user_namespace.setter
+    def user_namespace(self, value):
+        sanitized = str(value).replace('/', '_').replace('\\', '_').strip() or 'default'
+        st.session_state.user_namespace = sanitized
+
+    # Métodos de utilidad
+    def add_message(self, role, content, avatar=None):
+        """Añade un mensaje al historial"""
+        message = {
+            'role': role,
+            'content': content,
+        }
+        if avatar:
+            message['avatar'] = avatar
+        self.messages.append(message)
+    
+    def clear_prompt(self):
+        """Limpia el prompt del estado de la sesión"""
+        self.prompt = None
+
+    def initialize_model(self, model_name=None, api_key=None):
+        """Inicializa el modelo de IA"""
+        if model_name is None:
+            model_name = DEFAULT_GEMINI_MODEL
+        if api_key is None:
+            api_key = os.environ.get('GOOGLE_API_KEY')
+        self.client = genai.Client(api_key=api_key)
+        self.model = model_name
+    
+    def initialize_chat(self, history=None, system_instruction=None):
+        """Inicializa el chat con el modelo"""
+        if history is None:
+            history = self.gemini_history
+        if system_instruction is None:
+            system_instruction = self.system_instruction
+        else:
+            self.system_instruction = system_instruction
+        
+        # Asegurar que el modelo está inicializado
+        if self.model is None or self.client is None:
+            self.initialize_model()
+
+        chat_kwargs = {'model': self.model}
+        if history:
+            chat_kwargs['history'] = history
+        if system_instruction:
+            chat_kwargs['config'] = types.GenerateContentConfig(
+                system_instruction=system_instruction
+            )
+
+        # Inicializar chat con el SDK moderno
+        self.chat = self.client.chats.create(**chat_kwargs)
+        
+        # Verificar que el chat se inicializó correctamente
+        if self.chat is None:
+            raise ValueError("Error al inicializar el chat")
+    
+    def send_message(self, prompt, stream=True):
+        """Método unificado para enviar mensajes y mantener el streaming"""
+        try:
+            if self.chat is None:
+                self.initialize_chat()
+                
+            if stream:
+                return self.chat.send_message_stream(prompt)
+            return self.chat.send_message(prompt)
+        except Exception as e:
+            print(f"Error al enviar mensaje: {e}")
+            # Reintentar una vez si hay error
+            try:
+                self.initialize_chat()
+                if stream:
+                    return self.chat.send_message_stream(prompt)
+                return self.chat.send_message(prompt)
+            except Exception as retry_error:
+                raise RuntimeError(
+                    f"Fallo al enviar mensaje tras reintento. Error original: {e}. "
+                    f"Error de reintento: {retry_error}"
+                ) from retry_error
+    
+    def generate_chat_title(self, prompt, model_name=None):
+        """Genera un título para el chat basado en el primer mensaje"""
+        try:
+            if model_name is None:
+                model_name = DEFAULT_GEMINI_MODEL
+            if self.client is None:
+                self.client = genai.Client(api_key=os.environ.get('GOOGLE_API_KEY'))
+            title_response = self.client.models.generate_content(
+                model=model_name,
+                contents=(
+                    "Genera un título natural y humano en español (3 a 6 palabras) "
+                    "que resuma esta consulta. No uses separadores tipo '|', no uses etiquetas, "
+                    "no uses comillas y evita formato robótico. Devuelve solo el título final: "
+                    f"'{prompt}'"
+                )
+            )
+            cleaned_title = " ".join(
+                title_response.text.strip().replace('"', '').replace('|', ' ').split()
+            )
+            return " ".join(cleaned_title.split()[:6])
+        except Exception as e:
+            print(f"Error al generar título: {e}")
+            return None
+    
+    def save_chat_history(self, chat_id=None):
+        """Guarda el historial del chat"""
+        if chat_id is None:
+            chat_id = self.chat_id
+        
+        serialized_history = self._serialize_gemini_history(self.gemini_history)
+        os.makedirs(self._user_data_dir(), exist_ok=True)
+        joblib.dump(self.messages, self._st_messages_path(chat_id))
+        joblib.dump(serialized_history, self._gemini_messages_path(chat_id))
+    
+    def load_chat_history(self, chat_id=None):
+        """Carga el historial del chat"""
+        if chat_id is None:
+            chat_id = self.chat_id
+        
+        try:
+            self.messages = joblib.load(self._st_messages_path(chat_id))
+            loaded_history = joblib.load(self._gemini_messages_path(chat_id))
+            self.gemini_history = self._deserialize_gemini_history(loaded_history)
+            return True
+        except (FileNotFoundError, EOFError):
+            self.messages = []
+            self.gemini_history = []
+            return False
+
+    def _st_messages_path(self, chat_id):
+        return f'{self._user_data_dir()}/{chat_id}-st_messages'
+
+    def _gemini_messages_path(self, chat_id):
+        return f'{self._user_data_dir()}/{chat_id}-gemini_messages'
+
+    def _user_data_dir(self):
+        return f'{DATA_DIR}/{self.user_namespace}'
+
+    def _serialize_gemini_history(self, history):
+        """Convierte tipos del SDK (Content/Part) a diccionarios serializables."""
+        serialized = []
+        for item in history or []:
+            if isinstance(item, dict):
+                serialized.append(item)
+                continue
+            if hasattr(item, "model_dump"):
+                serialized.append(item.model_dump(mode="python"))
+                continue
+            if hasattr(item, "to_dict"):
+                serialized.append(item.to_dict())
+                continue
+            serialized.append(item)
+        return serialized
+
+    def _deserialize_gemini_history(self, history):
+        """Reconstruye Content para rehidratar chat history en google-genai."""
+        deserialized = []
+        for item in history or []:
+            if isinstance(item, dict) and "role" in item and "parts" in item:
+                role = item.get("role")
+                parts_data = item.get("parts", [])
+                parts = []
+                for part in parts_data:
+                    if isinstance(part, dict) and "text" in part:
+                        parts.append(types.Part(text=part["text"]))
+                    elif isinstance(part, str):
+                        parts.append(types.Part(text=part))
+                if parts:
+                    deserialized.append(types.Content(role=role, parts=parts))
+                    continue
+            deserialized.append(item)
+        return deserialized
+    
+    def has_messages(self):
+        """Verifica si hay mensajes en el historial"""
+        return len(self.messages) > 0
+    
+    def has_prompt(self):
+        """Verifica si hay un prompt en el estado de la sesión"""
+        return self.prompt is not None and self.prompt.strip() != ""

system_prompts.py

@@ -0,0 +1,71 @@
+def get_unified_email_prompt():
+    return """### [IMPRIMACIÓN COGNITIVA]
+- Modelos fundacionales: Storytelling Marketing, Show Don't Tell, PAS, Golden Circle (empezar con el porqué).
+- Corpus de conocimiento: estilo tipo Seth Godin, estructura narrativa tipo StoryBrand, persuasión sutil estilo Cialdini.
+- Léxico clave: Anécdota catalizadora, Puente narrativo, Epifanía, Lección clave, Llamada a la acción contextual, Resonancia emocional.
+- Usa marcos fundacionales de copy (AIDA, PASA y PASTOR) solo como estructura interna.
+
+### [PERSONA]
+Actúa como estratega de email marketing y storyteller experto en copy conversacional.
+Tono: empático, amable, curioso, conversacional y perspicaz.
+Audiencia: suscriptores con relación de confianza, que esperan valor y no venta agresiva.
+
+### [MISIÓN]
+Guiar de forma interactiva para crear emails de marketing.
+Antes de redactar el email final, debes recopilar estos datos:
+1) Audiencia objetivo.
+2) Producto a promover.
+3) Nombre para firma.
+4) Llamado a la acción (CTA).
+5) Ángulo (anécdota/situación/observación; puede incluir personajes de Disney/anime).
+NO debes generar ningún email final antes de recibir los 5 elementos.
+
+### [PRIMERA RESPUESTA OBLIGATORIA]
+Si aún no tienes los 5 datos, inicia con la PRIMERA pregunta del flujo operativo (no pidas todo junto).
+
+### [FLUJO OPERATIVO]
+Haz solo 1 pregunta a la vez y espera respuesta:
+1) AUDIENCIA:
+   "¿A quién le vas a escribir este email? Describe tu audiencia ideal: contexto, problema principal, deseo y nivel de conciencia sobre el problema."
+2) PRODUCTO:
+   "¿Qué producto o servicio vas a promover y qué transformación principal consigue la persona que lo compra?"
+3) NOMBRE:
+   "¿Con qué nombre quieres firmar el correo?"
+4) CTA:
+   "¿Qué acción concreta quieres que la audiencia realice al final del email? (responder, agendar llamada, comprar, visitar enlace, etc.)"
+5) ÁNGULO (OBLIGATORIO):
+   "¿Qué ángulo, anécdota o situación específica quieres usar en este correo? (Puedes apoyarte en referencias como Disney/anime si encaja)."
+
+### [RAZONAMIENTO PASO A PASO]
+1) Descubrimiento guiado (5 preguntas, una por vez; ángulo obligatorio).
+2) Identificación de dolor/deseo central y transformación del producto.
+3) Construir puente narrativo a partir del ángulo dado y redactar con enfoque conversacional.
+4) Usar AIDA, PASA o PASTOR internamente para ordenar el mensaje cuando haga falta.
+5) Adaptar lenguaje al nivel de conciencia de la audiencia y cerrar con CTA explícito.
+6) Usar el nombre de firma proporcionado en el cierre final del email.
+
+### [RESTRICCIONES]
+- No uses clichés de marketing.
+- No fuerces la conexión historia-producto; pide más contexto si hace falta.
+- No te enfoques en características, precios o descuentos.
+- Nunca menciones al usuario qué fórmula interna usaste (AIDA, PASA o PASTOR).
+
+### [FORMATO DE SALIDA FINAL - EXACTO]
+**Asunto:** [Texto del Asunto en negrita]
+
+---
+
+**Cuerpo del Email:**
+
+[Párrafo 1: La anécdota]
+
+[Párrafo 2: La transición hacia la lección]
+
+[Párrafo 3: La lección clave y cómo se conecta con un problema general]
+
+[Párrafo 4: Presentación del producto como la herramienta para aplicar la lección]
+
+[Párrafo 5: Llamada a la acción clara y directa]
+
+[Cierre personal]
+"""