src/agents/model_factory.py

import os
import traceback

def get_temperature():
    """
    Récupère la température depuis la variable d'environnement ou utilise une valeur par défaut.
    
    Returns:
        La température à utiliser pour les modèles (float entre 0 et 1)
    """
    try:
        temp_str = os.environ.get("MODEL_TEMPERATURE", "0.2")
        temp = float(temp_str)
        # Limiter la température entre 0 et 1
        temp = max(0.0, min(1.0, temp))
        return temp
    except ValueError:
        print(f"AVERTISSEMENT: La valeur MODEL_TEMPERATURE '{temp_str}' n'est pas un nombre valide. Utilisation de la valeur par défaut 0.2.")
        return 0.2

def get_hf_model():
    """
    Initialise et retourne un modèle Hugging Face via un endpoint personnalisé.
    
    Returns:
        Le modèle configuré ou None en cas d'erreur
    """
    hf_endpoint_url = os.environ.get("HUGGING_FACE_INFERENCE_ENDPOINT_URL")
    hf_token = os.environ.get("HUGGING_FACE_HUB_TOKEN")
    hf_model_name = os.environ.get("HUGGING_FACE_MODEL_NAME", "google/gemma-3-12b-it")
    temperature = get_temperature()
    
    # Vérifier que les variables d'environnement sont définies
    if not hf_endpoint_url or not hf_token:
        print("ERREUR: HUGGING_FACE_INFERENCE_ENDPOINT_URL ou HUGGING_FACE_HUB_TOKEN non configuré.")
        return None
    
    print(f"Utilisation du modèle {hf_model_name} via endpoint personnalisé: {hf_endpoint_url}")
    print(f"Température configurée: {temperature}")
    
    try:
        # Utiliser OpenAIServerModel qui est plus adapté pour les endpoints d'inférence
        from smolagents import OpenAIServerModel
        
        model = OpenAIServerModel(
            model_id=hf_model_name,
            api_base=hf_endpoint_url,
            api_key=hf_token,
            temperature=temperature
        )
        
        print("Modèle OpenAIServerModel initialisé avec succès!")
        return model
    except Exception as e:
        error_trace = traceback.format_exc()
        print(f"ERREUR lors de l'initialisation de OpenAIServerModel: {e}")
        print(f"Traceback complet: {error_trace}")
        return None

def get_openai_model():
    """
    Initialise et retourne un modèle OpenAI GPT-4o.
    
    Returns:
        Le modèle configuré ou None en cas d'erreur
    """
    openai_api_key = os.environ.get("OPENAI_API_KEY")
    temperature = get_temperature()
    
    if not openai_api_key:
        print("ERREUR: OPENAI_API_KEY non configuré.")
        return None
    
    try:
        # Configuration pour OpenAI
        from smolagents import LiteLLMModel
        
        print("Utilisation du modèle OpenAI GPT-4o")
        print(f"Température configurée: {temperature}")
        
        return LiteLLMModel(
            "gpt-4o",
            temperature=temperature,
            api_key=openai_api_key
        )
    except Exception as e:
        error_trace = traceback.format_exc()
        print(f"ERREUR lors de l'initialisation de LiteLLMModel: {e}")
        print(f"Traceback complet: {error_trace}")
        return None

def get_model():
    """
    Retourne le modèle à utiliser en fonction de MODEL_PROVIDER.
    
    Returns:
        Un modèle configuré ou None en cas d'erreur
    """
    # Récupérer le modèle à utiliser depuis les variables d'environnement
    model_provider = os.environ.get("MODEL_PROVIDER", "openai").lower()
    
    if model_provider == "huggingface":
        model = get_hf_model()
        if model:
            return model
        print("Passage à OpenAI suite à l'erreur.")
        model_provider = "openai"
    
    if model_provider == "openai":
        return get_openai_model()
    
    # Si on arrive ici, c'est que MODEL_PROVIDER n'est ni huggingface ni openai
    print(f"ERREUR: MODEL_PROVIDER '{model_provider}' non reconnu. Utiliser 'huggingface' ou 'openai'")
    return None