streamlit_app.py

import streamlit as st
import os
import sys
import yaml
import datetime
import pytz
import pandas as pd
import numpy as np
from typing import List, Dict, Any, Optional, Union, Tuple

# Ajout du répertoire courant au chemin Python pour importer les modules
sys.path.append(os.path.dirname(os.path.abspath(__file__)))

# Import des composants nécessaires pour l'agent
from smolagents import CodeAgent
from smolagents.models import OpenAIServerModel, HfApiModel
from tools.final_answer import FinalAnswerTool
from tools.validate_final_answer import ValidateFinalAnswer
from tools.visit_webpage import VisitWebpageTool
from tools.web_search import DuckDuckGoSearchTool
from tools.shell_tool import ShellCommandTool
from tools.create_file_tool import CreateFileTool
from tools.modify_file_tool import ModifyFileTool
from phoenix.otel import register
from openinference.instrumentation.smolagents import SmolagentsInstrumentor
from smolagents.memory import ToolCall
# register()
# SmolagentsInstrumentor().instrument()

# Import des fonctions de visualisation
from visualizations import (
    create_line_chart,
    create_bar_chart,
    create_scatter_plot,
    detect_visualization_request,
    generate_sample_data
)

# Configuration de la page Streamlit
st.set_page_config(
    page_title="Agent Conversationnel SmoLAgents 🤖",
    page_icon="🤖",
    layout="wide",
)

def initialize_agent(model_type="openai_server", model_config=None):
    """Initialise l'agent avec les outils et le modèle choisi
    
    Args:
        model_type: Type de modèle à utiliser ('openai_server', 'hf_api', etc.)
        model_config: Configuration spécifique au modèle
    """
    
    # Configuration du modèle en fonction du type choisi
    if model_type == "openai_server":
        # Configuration par défaut pour OpenAIServerModel
        if model_config is None:
            model_config = {
                "api_base": "https://openrouter.ai/api/v1",
                "model_id": "google/gemini-2.0-pro-exp-02-05:free",
                "api_key": "nop"
            }
        
        model = OpenAIServerModel(
            api_base=model_config["api_base"],
            model_id=model_config["model_id"],
            api_key=model_config["api_key"],
            max_tokens=12000
        )
    
    elif model_type == "hf_api":
        # Configuration par défaut pour HfApiModel
        if model_config is None:
            model_config = {
                "model_id": "http://192.168.1.141:1234/v1",
                "max_new_tokens": 2096,
                "temperature": 0.5
            }
        
        model = HfApiModel(
            model_id=model_config["model_id"],
            max_new_tokens=model_config["max_new_tokens"],
            temperature=model_config["temperature"]
        )
    
    elif model_type == "hf_cloud":
        # Configuration pour HfApiModel avec un endpoint cloud
        if model_config is None:
            model_config = {
                "model_id": "https://pflgm2locj2t89co.us-east-1.aws.endpoints.huggingface.cloud",
                "max_new_tokens": 2096,
                "temperature": 0.5
            }
        
        model = HfApiModel(
            model_id=model_config["model_id"],
            max_new_tokens=model_config["max_new_tokens"],
            temperature=model_config["temperature"]
        )
    
    else:
        st.error(f"Type de modèle non supporté: {model_type}")
        return None
    
    # Chargement des templates de prompt depuis le fichier YAML
    try:
        with open("prompts.yaml", 'r') as stream:
            prompt_templates = yaml.safe_load(stream)
    except:
        st.error("Impossible de charger prompts.yaml. Utilisation des prompts par défaut.")
        prompt_templates = None
    
    
    # Création de l'agent avec les mêmes outils que dans app.py
    agent = CodeAgent(
        model=model,
        tools=[
            FinalAnswerTool(), 
            ValidateFinalAnswer(),
            DuckDuckGoSearchTool(), 
            VisitWebpageTool(), 
            ShellCommandTool(), 
            CreateFileTool(), 
            ModifyFileTool()
        ],
        max_steps=20,
        verbosity_level=1,
        grammar=None,
        planning_interval=None,
        name=None,
        description=None,
        prompt_templates=prompt_templates,
        additional_authorized_imports=["pandas", "numpy", "matplotlib", "seaborn", "plotly", "requests", "yaml"]
    )
    
    return agent

def format_step_message(step, is_final=False):
    """Formate les messages de l'agent pour l'affichage dans Streamlit"""
    
    if hasattr(step, "model_output") and step.model_output:
        # Nettoyer et formater la sortie du modèle pour l'affichage
        content = step.model_output.strip()
        if not is_final:
            return content
        else:
            return f"**Réponse finale :** {content}"
    
    if hasattr(step, "observations") and step.observations:
        # Afficher les observations des outils
        return f"**Observations :** {step.observations.strip()}"
    
    if hasattr(step, "error") and step.error:
        # Afficher les erreurs
        return f"**Erreur nooo:** {step.error}"
    
    # Cas par défaut
    return str(step)

def process_visualization_request(user_input: str) -> Tuple[bool, Optional[st.delta_generator.DeltaGenerator]]:
    """
    Process a visualization request from the user.
    
    Args:
        user_input: The user's input message.
        
    Returns:
        A tuple containing:
        - Boolean indicating if a visualization was processed
        - The Streamlit delta generator if a visualization was created, None otherwise
    """
    # Detect if this is a visualization request
    viz_info = detect_visualization_request(user_input)
    
    if not viz_info['is_visualization'] or not viz_info['chart_type']:
        return False, None
    
    # Extract information from the request
    chart_type = viz_info['chart_type']
    data_description = viz_info['data_description']
    parameters = viz_info['parameters']
    
    # Generate sample data based on the description and chart type
    data = generate_sample_data(data_description, chart_type)
    
    # Set default parameters if not provided
    title = parameters.get('title', f"{chart_type.capitalize()} Chart" + (f" of {data_description}" if data_description else ""))
    x_label = parameters.get('x_label', data.columns[0] if len(data.columns) > 0 else "X-Axis")
    y_label = parameters.get('y_label', data.columns[1] if len(data.columns) > 1 else "Y-Axis")
    
    # Create the appropriate chart
    fig = None
    if chart_type == 'line':
        fig = create_line_chart(data, title=title, x_label=x_label, y_label=y_label)
    elif chart_type == 'bar':
        fig = create_bar_chart(data, title=title, x_label=x_label, y_label=y_label)
    elif chart_type == 'scatter':
        fig = create_scatter_plot(data, title=title, x_label=x_label, y_label=y_label)
    
    if fig:
        # Create a container for the visualization
        viz_container = st.container()
        with viz_container:
            st.plotly_chart(fig, use_container_width=True)
        
        return True, viz_container
    
    return False, None

def process_user_input(agent, user_input):
    """Traite l'entrée utilisateur avec l'agent et renvoie les résultats étape par étape"""
    
    # Check if this is a visualization request
    is_viz_request, viz_container = process_visualization_request(user_input)
    
    # If it's a visualization request, we'll still run the agent but we've already displayed the chart
    
    # Vérification de la connexion au serveur LLM
    try:
        # Exécution de l'agent et capture des étapes
        with st.spinner("L'agent réfléchit..."):
            # Placeholder pour la sortie de l'agent
            response_container = st.container()
            
            # Exécution de l'agent et capture des étapes
            steps = []
            final_step = None
            
            with response_container:
                step_container = st.empty()
                step_text = ""
                
                # Exécute l'agent et capture les étapes de manière incrémentale
                for step in agent.run(user_input, stream=True):
                    steps.append(step)
                    
                    # Mettre à jour l'affichage des étapes
                    step_number = f"Étape {step.step_number}" if hasattr(step, "step_number") and step.step_number is not None else ""
                    step_content = format_step_message(step)
                    
                    # Ajouter au texte des étapes
                    if step_number:
                        step_text += f"### {step_number}\n\n"
                    step_text += f"{step_content}\n\n---\n\n"
                    
                    # Mettre à jour l'affichage
                    step_container.markdown(step_text)
                    
                    # Conserver la dernière étape pour la réponse finale
                    final_step = step
                
                # Afficher la réponse finale
                if final_step:
                    final_answer = format_step_message(final_step, is_final=True)
                    
                    # If this was a visualization request, add a note about the visualization
                    if is_viz_request:
                        final_answer += "\n\n*Une visualisation a été générée en fonction de votre demande.*"
                    
                    return (final_answer, True)
            
            return final_step
    except Exception as e:
        st.error(f"Erreur lors de l'exécution de l'agent: {str(e)}")
        return None

def main():
    st.title("Agent Conversationnel SmoLAgents 🤖")
    
    st.markdown("""
    Bienvenue! Cet agent utilise SmoLAgents pour se connecter à un modèle de langage.
    Posez vos questions ci-dessous.
    """)
    
    # Sidebar pour la configuration du modèle
    with st.sidebar:
        st.title("Configuration du Modèle")
        
        # Sélectionner le type de modèle
        model_type = st.selectbox(
            "Type de modèle",
            ["openai_server", "hf_api", "hf_cloud"],
            index=0,
            help="Choisissez le type de modèle à utiliser avec l'agent"
        )
        
        # Configuration spécifique en fonction du type de modèle
        model_config = {}
        
        if model_type == "openai_server":
            st.subheader("Configuration OpenAI Server")
            model_config["api_base"] = st.text_input(
                "URL du serveur",
                value="https://openrouter.ai/api/v1",
                help="Adresse du serveur OpenAI compatible"
            )
            model_config["model_id"] = st.text_input(
                "ID du modèle",
                value="google/gemini-2.0-pro-exp-02-05:free",
                help="Identifiant du modèle local"
            )
            model_config["api_key"] = st.text_input(
                "Clé API",
                value="nop",
                type="password",
                help="Clé API pour le serveur (dummy pour LMStudio)"
            )
        
        elif model_type == "hf_api":
            st.subheader("Configuration Hugging Face API")
            model_config["model_id"] = st.text_input(
                "URL du modèle",
                value="http://192.168.1.141:1234/v1",
                help="URL du modèle ou endpoint"
            )
            model_config["max_new_tokens"] = st.slider(
                "Tokens maximum",
                min_value=512,
                max_value=4096,
                value=2096,
                help="Nombre maximum de tokens à générer"
            )
            model_config["temperature"] = st.slider(
                "Température",
                min_value=0.1,
                max_value=1.0,
                value=0.5,
                step=0.1,
                help="Température pour la génération (plus élevée = plus créatif)"
            )
        
        elif model_type == "hf_cloud":
            st.subheader("Configuration Hugging Face Cloud")
            model_config["model_id"] = st.text_input(
                "URL du endpoint cloud",
                value="https://pflgm2locj2t89co.us-east-1.aws.endpoints.huggingface.cloud",
                help="URL de l'endpoint cloud Hugging Face"
            )
            model_config["max_new_tokens"] = st.slider(
                "Tokens maximum",
                min_value=512,
                max_value=4096,
                value=2096,
                help="Nombre maximum de tokens à générer"
            )
            model_config["temperature"] = st.slider(
                "Température",
                min_value=0.1,
                max_value=1.0,
                value=0.5,
                step=0.1,
                help="Température pour la génération (plus élevée = plus créatif)"
            )
        
        # Bouton pour réinitialiser l'agent avec la nouvelle configuration
        if st.button("Appliquer la configuration"):
            with st.spinner("Initialisation de l'agent avec le nouveau modèle..."):
                st.session_state.agent = initialize_agent(model_type, model_config)
                st.success("✅ Configuration appliquée avec succès!")
    
    # Vérifier la connexion au serveur
    if model_type == "openai_server":
        llm_api_url = model_config["api_base"].split("/v1")[0]
        try:
            import requests
            response = requests.get(f"{llm_api_url}/health", timeout=2)
            if response.status_code == 200:
                st.success("✅ Connexion au serveur LLM établie")
            else:
                st.warning("⚠️ Le serveur LLM est accessible mais renvoie un statut non-OK")
        except Exception:
            st.error("❌ Impossible de se connecter au serveur LLM. Vérifiez que le serveur est en cours d'exécution à l'adresse spécifiée.")
    
    # Initialisation de l'agent si ce n'est pas déjà fait
    if "agent" not in st.session_state:
        with st.spinner("Initialisation de l'agent..."):
            st.session_state.agent = initialize_agent(model_type, model_config)
    
    # Initialisation de l'historique de conversation
    if "messages" not in st.session_state:
        st.session_state.messages = [
            {"role": "assistant", "content": "Bonjour! Comment puis-je vous aider aujourd'hui?"}
        ]
    
    # Affichage de l'historique des messages
    for message in st.session_state.messages:
        with st.chat_message(message["role"]):
            st.markdown(message["content"])
    
    # Zone de saisie utilisateur
    if prompt := st.chat_input("Posez votre question..."):
        # Ajouter la question de l'utilisateur à l'historique
        st.session_state.messages.append({"role": "user", "content": prompt})
        
        # Afficher la question de l'utilisateur
        with st.chat_message("user"):
            st.markdown(prompt)
        
        # Traiter la demande avec l'agent
        with st.chat_message("assistant"):
            response = process_user_input(st.session_state.agent, prompt)
            if response is not None and  response[1] == True:
                with st.container(border = True):
                    def secure_imports(code_str):
                        """
                        Process Python code to replace import statements with exec-wrapped versions.
                        
                        Args:
                            code_str (str): The Python code string to process
                            
                        Returns:
                            str: The processed code with import statements wrapped in exec()
                        """
                        import re
                        
                        # Define regex patterns for both import styles
                        # Pattern for 'import module' and 'import module as alias'
                        import_pattern = r'^(\s*)import\s+([^\n]+)'
                        
                        # Pattern for 'from module import something'
                        from_import_pattern = r'^(\s*)from\s+([^\n]+)\s+import\s+([^\n]+)'
                        
                        lines = code_str.split('\n')
                        result_lines = []
                        
                        i = 0
                        while i < len(lines):
                            line = lines[i]
                            
                            # Check for multiline imports with parentheses
                            if re.search(r'import\s+\(', line) or re.search(r'from\s+.+\s+import\s+\(', line):
                                # Collect all lines until closing parenthesis
                                start_line = i
                                multiline_import = [line]
                                i += 1
                                
                                while i < len(lines) and ')' not in lines[i]:
                                    multiline_import.append(lines[i])
                                    i += 1
                                    
                                if i < len(lines):  # Add the closing line with parenthesis
                                    multiline_import.append(lines[i])
                                    
                                # Join the multiline import and wrap it with exec
                                indentation = re.match(r'^(\s*)', multiline_import[0]).group(1)
                                multiline_str = '\n'.join(multiline_import)
                                result_lines.append(f'{indentation}exec("""\n{multiline_str}\n""")')
                                
                            else:
                                # Handle single line imports
                                import_match = re.match(import_pattern, line)
                                from_import_match = re.match(from_import_pattern, line)
                                
                                if import_match:
                                    indentation = import_match.group(1)
                                    import_stmt = line[len(indentation):]  # Remove indentation from statement
                                    result_lines.append(f'{indentation}exec("{import_stmt}")')
                                    
                                elif from_import_match:
                                    indentation = from_import_match.group(1)
                                    from_import_stmt = line[len(indentation):]  # Remove indentation from statement
                                    result_lines.append(f'{indentation}exec("{from_import_stmt}")')
                                    
                                else:
                                    # Not an import statement, keep as is
                                    result_lines.append(line)
                            
                            i += 1
                            
                        return '\n'.join(result_lines)

                    # Process response[0] to secure import statements
                    # processed_response = secure_imports(response[0])
                    # eval(processed_response)
                    exec(response[0])
            if response and hasattr(response, "model_output"):
                # Ajouter la réponse à l'historique
                st.session_state.messages.append({"role": "assistant", "content": response.model_output})
    
    # Bouton pour effacer l'historique
    if st.sidebar.button("Nouvelle conversation"):
        st.session_state.messages = [
            {"role": "assistant", "content": "Bonjour! Comment puis-je vous aider aujourd'hui?"}
        ]
        st.rerun()
    
    # Afficher des informations supplémentaires dans la barre latérale
    with st.sidebar:
        st.title("À propos de cet agent")
        st.markdown("""
        Cet agent utilise SmoLAgents pour se connecter à un modèle de langage hébergé localement.
        
        ### Outils disponibles
        - Recherche web (DuckDuckGo)
        - Visite de pages web
        - Exécution de commandes shell
        - Création et modification de fichiers
        - Visualisations de données (nouveauté!)
        
        ### Configuration
        Utilisez les options ci-dessus pour configurer le modèle de langage.
        
        ### Problèmes courants
        - Si l'agent ne répond pas, vérifiez que le serveur LLM est en cours d'exécution et accessible.
        - Assurez-vous que toutes les dépendances sont installées via `pip install -r requirements.txt`.
        """)
        
        # Section pour les visualisations
        st.subheader("Visualisations")
        st.markdown("""
        Vous pouvez demander des visualisations en utilisant des phrases comme:
        - "Montre-moi un graphique en ligne des températures"
        - "Crée un diagramme à barres des ventes par région"
        - "Affiche un nuage de points de l'âge vs revenu"
        
        L'agent détectera automatiquement votre demande et générera une visualisation appropriée.
        """)
        
        # Afficher l'heure actuelle dans différents fuseaux horaires
        st.subheader("Heure actuelle")
        selected_timezone = st.selectbox(
            "Choisissez un fuseau horaire",
            ["Europe/Paris", "America/New_York", "Asia/Tokyo", "Australia/Sydney"]
        )
        
        tz = pytz.timezone(selected_timezone)
        local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")
        st.write(f"L'heure actuelle à {selected_timezone} est: {local_time}")

if __name__ == "__main__":
    main()