# main.py — ADN NEXUS V10.5.1 (correction tokenizer Qwen2.5)
# Ajout de fallback pour tokenizer, et fallback modèle si nécessaire

# ... (tout le code précédent, inchangé jusqu'à la classe LocalInference)

class LocalInference:
    def __init__(self):
        self.model = None
        self.tokenizer = None
        self.model_name = Config.MODEL_NAME
        self.is_loading = True
        self.load_error = None
        self._load_task = None

    async def initialize(self):
        self._load_task = asyncio.create_task(self._load_model())
        await self._load_task

    async def _load_model(self):
        device = Config.DEVICE
        # Liste des modèles à essayer en cas d'échec du tokenizer
        models_to_try = [
            self.model_name,
            "Qwen/Qwen1.5-1.8B-Chat",
            "TinyLlama/TinyLlama-1.1B-Chat-v1.0",
        ]
        for model_name in models_to_try:
            try:
                logger.info(f"Tentative de chargement: {model_name}")
                loop = asyncio.get_running_loop()
                def _load():
                    # Chargement du tokenizer avec trust_remote_code et use_fast=False
                    try:
                        tokenizer = AutoTokenizer.from_pretrained(
                            model_name,
                            token=Config.HF_TOKEN,
                            trust_remote_code=True,
                            use_fast=False,
                        )
                    except Exception as e:
                        # Fallback : essayer avec les paramètres par défaut
                        logger.warning(f"Tokenizer avec use_fast=False échoué: {e}, tentative par défaut")
                        tokenizer = AutoTokenizer.from_pretrained(
                            model_name,
                            token=Config.HF_TOKEN,
                            trust_remote_code=True,
                        )
                    # Chargement du modèle
                    model = AutoModelForCausalLM.from_pretrained(
                        model_name,
                        token=Config.HF_TOKEN,
                        trust_remote_code=True,
                        dtype=torch.float16 if device == "cuda" else torch.float32,
                        low_cpu_mem_usage=True,
                    )
                    model.to(device)
                    model.eval()
                    return tokenizer, model

                self.tokenizer, self.model = await loop.run_in_executor(None, _load)
                self.model_name = model_name
                self.is_loading = False
                logger.info(f"Modele charge avec succes: {model_name}")
                return
            except Exception as e:
                logger.warning(f"Echec chargement {model_name}: {e}")
                continue
        self.is_loading = False
        self.load_error = "Aucun modele n'a pu etre charge"
        logger.error(self.load_error)

    # ... (reste du code inchangé)