feat: intégration du panneau super-admin (clés API/SMTP), recherche web native OpenRouter, cookie étendu (8h), toast notification et reset textarea

backend/main.py

@@ -3,15 +3,15 @@ from fastapi.responses import RedirectResponse, FileResponse
 from fastapi.staticfiles import StaticFiles
 from sqlalchemy.orm import Session
 from typing import List
-import os, json, asyncio, shutil
+import os, json, asyncio, shutil, base64, io, csv, zipfile
-from datetime import datetime
+from datetime import datetime, timedelta, timezone
 import pytz
 
 from .database import engine, Base, get_db, SessionLocal
 from .auth import get_password_hash, generate_totp_secret, get_totp_uri, verify_password, verify_totp, create_access_token, verify_token
-from .schemas import AdminCreate, LoginRequest, ProjectCreate, ProjectResponse, ProjectRename, MessageCreate, MessageResponse, PasswordChange
+from .schemas import AdminCreate, LoginRequest, ProjectCreate, ProjectResponse, ProjectRename, MessageCreate, MessageResponse, PasswordChange, ModelReplacementRequest, LogRequest, SystemSettingsUpdate, SystemSettingsResponse
 from .models import User, Project, Message, SystemSettings, AIModel, FinancialLog
-from .orchestrator import run_orchestrator, sync_providers_models, sync_finances
+from .orchestrator import run_orchestrator, sync_providers_models, sync_finances, activity_logs, log_activity
 
 Base.metadata.create_all(bind=engine)
 app = FastAPI(title="AETHAS38")
@@ -28,11 +28,25 @@ async def scheduler_task():
         now = datetime.now(tz)
         if (now.hour == 0 or now.hour == 12) and now.minute == 0:
             db = SessionLocal()
-            settings = db.query(SystemSettings).first()
+            try:
-            if settings:
+                settings = db.query(SystemSettings).first()
-                try: await sync_providers_models(db, settings, "Automatique")
+                if settings:
-                except: pass
+                    try: await sync_providers_models(db, settings, "Automatique")
-            db.close()
+                    except: pass
+                
+                cutoff = datetime.now(timezone.utc) - timedelta(days=7)
+                old_projects = db.query(Project).filter(Project.is_pinned == False, Project.created_at < cutoff).all()
+                if old_projects:
+                    log_activity(f"[Nettoyage] Suppression de {len(old_projects)} discussion(s) de plus de 7 jours.")
+                    for op in old_projects:
+                        db.delete(op)
+                    db.commit()
+            except Exception as e:
+                db.rollback()
+                log_activity(f"[Erreur Nettoyage] {str(e)}")
+            finally:
+                db.close()
+            
             await asyncio.sleep(60)
         await asyncio.sleep(30)
 
@@ -73,7 +87,9 @@ def login(login_data: LoginRequest, response: Response, db: Session = Depends(ge
     user = db.query(User).filter(User.username == login_data.username).first()
     if not user or not verify_password(login_data.password, user.hashed_password): raise HTTPException(status_code=401, detail="Identifiants incorrects.")
     if not verify_totp(user.totp_secret, login_data.totp_code): raise HTTPException(status_code=401, detail="2FA invalide.")
-    response.set_cookie(key="session_token", value=create_access_token(data={"sub": user.username}), httponly=True, max_age=3600, samesite="lax")
+    
+    # Session valide 8 heures (28800 secondes)
+    response.set_cookie(key="session_token", value=create_access_token(data={"sub": user.username}), httponly=True, max_age=28800, samesite="lax")
     return {"message": "Connexion réussie"}
 
 @app.get("/dashboard")
@@ -82,6 +98,52 @@ def dashboard(request: Request):
     if not token or not verify_token(token): return RedirectResponse(url="/login")
     return FileResponse(os.path.join(os.getcwd(), "frontend", "dashboard.html"))
 
+@app.get("/api/logs")
+def get_logs():
+    return {"logs": activity_logs}
+
+@app.post("/api/logs")
+def add_frontend_log(req: LogRequest):
+    log_activity(f"[Système UI] {req.message}")
+    return {"status": "ok"}
+
+@app.post("/api/models/suggest_replacement")
+async def suggest_replacement(req: ModelReplacementRequest, db: Session = Depends(get_db)):
+    log_activity(f"⚠️ Modèle indisponible: {req.missing_model}. Demande de suggestion à Gemini...")
+    settings = db.query(SystemSettings).first()
+    if not settings or not settings.gemini_api_key:
+        log_activity("Clé Gemini non trouvée. Fallback forcé sur gemini-3.5-flash-lite.")
+        return {"suggestion": "gemini-3.5-flash-lite", "reason": "Clé API Gemini non configurée dans le système."}
+
+    models = db.query(AIModel).all()
+    available = [m.model_id for m in models]
+    
+    prompt = f"Le modèle IA '{req.missing_model}' n'est plus disponible. Voici les modèles disponibles : {', '.join(available)}. Trouve le modèle le plus proche techniquement. Réponds UNIQUEMENT avec ce format strict : ID_DU_MODELE | Brève explication en français de 10 mots max. Si aucun ne correspond, renvoie gemini-3.5-flash-lite | Par défaut."
+    
+    try:
+        from openai import AsyncOpenAI
+        client = AsyncOpenAI(base_url="https://generativelanguage.googleapis.com/v1beta/openai/", api_key=settings.gemini_api_key)
+        resp = await client.chat.completions.create(model="gemini-3.5-flash-lite", messages=[{"role": "user", "content": prompt}], max_tokens=50)
+        res = resp.choices[0].message.content.strip()
+        
+        if "|" in res:
+            parts = res.split("|")
+            sugg = parts[0].strip()
+            reason = parts[1].strip()
+        else:
+            sugg = res.strip()
+            reason = "Sélectionné par Gemini."
+            
+        if sugg not in available and sugg != "gemini-3.5-flash-lite":
+            sugg = "gemini-3.5-flash-lite"
+            reason = "Gemini a suggéré un modèle invalide. Fallback par défaut."
+
+        log_activity(f"✅ Remplacement trouvé : {req.missing_model} -> {sugg}")
+        return {"suggestion": sugg, "reason": reason}
+    except Exception as e:
+        log_activity(f"Erreur d'interrogation Gemini: {str(e)}. Fallback par défaut.")
+        return {"suggestion": "gemini-3.5-flash-lite", "reason": f"Erreur API."}
+
 @app.get("/api/users/me")
 def get_me(current_user: User = Depends(get_current_user)):
     return {"username": current_user.username, "is_admin": current_user.is_admin, "is_superadmin": current_user.is_superadmin, "avatar_path": current_user.avatar_path}
@@ -102,6 +164,23 @@ async def upload_avatar(file: UploadFile = File(...), db: Session = Depends(get_
     db.commit()
     return {"message": "Avatar mis à jour", "avatar_path": current_user.avatar_path}
 
+# --- ROUTES SUPER-ADMIN ---
+@app.get("/api/settings", response_model=SystemSettingsResponse)
+def get_settings(db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
+    if not current_user.is_superadmin: raise HTTPException(status_code=403, detail="Super-Admin requis.")
+    return db.query(SystemSettings).first()
+
+@app.put("/api/settings")
+def update_settings(settings_data: SystemSettingsUpdate, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
+    if not current_user.is_superadmin: raise HTTPException(status_code=403, detail="Super-Admin requis.")
+    s = db.query(SystemSettings).first()
+    if not s: raise HTTPException(status_code=404)
+    for k, v in settings_data.dict(exclude_unset=True).items():
+        setattr(s, k, v)
+    db.commit()
+    log_activity("Configuration système mise à jour par le Super-Admin.")
+    return {"message": "Paramètres mis à jour avec succès."}
+
 @app.get("/api/projects", response_model=List[ProjectResponse])
 def get_projects(db: Session = Depends(get_db), current_user: User = Depends(get_current_user)): return db.query(Project).filter(Project.user_id == current_user.id).order_by(Project.created_at.desc()).all()
 
@@ -143,14 +222,89 @@ def get_messages(project_id: int, db: Session = Depends(get_db), current_user: U
 
 @app.post("/api/projects/{project_id}/messages", response_model=List[MessageResponse])
 async def create_message(project_id: int, message: MessageCreate, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
-    db.add(Message(role=message.role, content=message.content, project_id=project_id)); db.commit()
+    p = db.query(Project).filter(Project.id == project_id).first()
+    if p and p.title == "Nouvelle discussion":
+        user_msgs = db.query(Message).filter(Message.project_id == project_id, Message.role == "user").order_by(Message.created_at.asc()).all()
+        if len(user_msgs) == 1:
+            first_content = user_msgs[0].content.split("\n\n[Fichiers joints")[0].strip()
+            new_title = first_content.split('\n')[0][:35].strip()
+            if not new_title: new_title = "Discussion"
+            p.title = new_title + ("..." if len(first_content) > 35 else "")
+            db.commit()
+
+    extracted_files_data = []
+    files_names = []
+    
+    if message.files:
+        for f in message.files:
+            files_names.append(f.name)
+            content = f.content
+            if content.startswith("data:"):
+                try:
+                    header, b64data = content.split(",", 1)
+                    file_bytes = base64.b64decode(b64data)
+                    ext = f.name.split('.')[-1].lower()
+                    extracted_text = ""
+
+                    if ext == 'pdf':
+                        try:
+                            import PyPDF2
+                            reader = PyPDF2.PdfReader(io.BytesIO(file_bytes))
+                            extracted_text = "\n".join([page.extract_text() for page in reader.pages if page.extract_text()])
+                        except ImportError:
+                            extracted_text = "[Erreur: L'administrateur doit exécuter 'pip install PyPDF2' sur le serveur pour lire les PDF.]"
+                    
+                    elif ext in ['xls', 'xlsx', 'xlsm', 'xlsb']:
+                        try:
+                            import openpyxl
+                            wb = openpyxl.load_workbook(io.BytesIO(file_bytes), data_only=False)
+                            for sheet_name in wb.sheetnames:
+                                sheet = wb[sheet_name]
+                                extracted_text += f"\n--- Feuille : {sheet_name} ---\n"
+                                for row in sheet.iter_rows(values_only=True):
+                                    row_vals = [str(cell) if cell is not None else "" for cell in row]
+                                    if any(row_vals):
+                                        extracted_text += "\t".join(row_vals) + "\n"
+                            
+                            if ext in ['xlsm', 'xlsb', 'xls']:
+                                try:
+                                    from oletools.olevba import VBA_Parser
+                                    vbaparser = VBA_Parser("filename", data=file_bytes)
+                                    if vbaparser.detect_vba_macros():
+                                        extracted_text += "\n\n--- MACROS VBA DETECTEES ---\n"
+                                        for (filename, stream_path, vba_filename, vba_code) in vbaparser.extract_macros():
+                                            extracted_text += f"\n// Module: {vba_filename}\n{vba_code}\n"
+                                except ImportError:
+                                    extracted_text += "\n[Extraction VBA impossible: L'administrateur doit exécuter 'pip install oletools' sur le serveur.]\n"
+                                except Exception as e:
+                                    extracted_text += f"\n[Erreur de lecture VBA interne: {str(e)}]\n"
+
+                        except ImportError:
+                            extracted_text = "[Erreur: L'administrateur doit exécuter 'pip install openpyxl' sur le serveur pour lire Excel.]"
+                    else:
+                        extracted_text = file_bytes.decode('utf-8', errors='replace')
+                    
+                    extracted_files_data.append({"name": f.name, "content": extracted_text})
+                except Exception as e:
+                    extracted_files_data.append({"name": f.name, "content": f"[ERREUR DE DECODAGE: {str(e)}]"})
+            else:
+                extracted_files_data.append({"name": f.name, "content": content})
+
+    db_content = message.content
+    if files_names:
+        db_content += f"\n\n[Fichiers joints pour analyse : {', '.join(files_names)}]"
+
+    db.add(Message(role=message.role, content=db_content, project_id=project_id))
+    db.commit()
+    
     history = db.query(Message).filter(Message.project_id == project_id).order_by(Message.created_at.asc()).all()
     settings = db.query(SystemSettings).first()
     conf = message.config.dict() if message.config else {"workers": ["gemini-3.5-flash-lite"]} 
     
-    ai_resp = await run_orchestrator(db, history, settings, conf) # Transmission de DB
+    ai_resp = await run_orchestrator(db, history, settings, conf, extracted_files_data)
     
-    db.add(Message(role="assistant", content=ai_resp, project_id=project_id)); db.commit()
+    db.add(Message(role="assistant", content=ai_resp, project_id=project_id))
+    db.commit()
     return db.query(Message).filter(Message.project_id == project_id).order_by(Message.created_at.asc()).all()
 
 # --- ROUTES MODÈLES & FINANCES ---
@@ -177,6 +331,37 @@ async def trigger_model_sync(db: Session = Depends(get_db), current_user: User =
 @app.get("/api/models/export")
 def export_models(db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
     if not current_user.is_admin: raise HTTPException(status_code=403, detail="Accès admin requis.")
-    models = db.query(AIModel).all()
+    models = db.query(AIModel).order_by(AIModel.provider.asc(), AIModel.name.asc()).all()
-    data = [{"provider": m.provider, "model_id": m.model_id, "name": m.name, "description_fr": m.description_fr, "domain": m.domain, "is_free": m.is_free, "context_length": m.context_length, "pricing_prompt": m.pricing_prompt, "pricing_completion": m.pricing_completion} for m in models]
+
-    return Response(content=json.dumps(data), media_type="application/json", headers={"Content-Disposition": "attachment; filename=aethas38_models.json"})
+    csv_io = io.StringIO()
+    writer = csv.writer(csv_io, delimiter=',')
+    writer.writerow(["Provider", "Model ID", "Name", "Domain", "Is Free", "Context Length", "Pricing Prompt", "Pricing Completion", "Description"])
+    for m in models:
+        writer.writerow([m.provider, m.model_id, m.name, m.domain, m.is_free, m.context_length, m.pricing_prompt, m.pricing_completion, m.description_fr])
+    
+    md_content = f"# Extraction des Modèles IA - AETHAS38\n\n**Date d'extraction :** {datetime.now().strftime('%d/%m/%Y à %H:%M:%S')}\n\n"
+    providers = sorted(list(set(m.provider for m in models)))
+    for prov in providers:
+        md_content += f"## Fournisseur : {prov.upper()}\n\n"
+        prov_models = [m for m in models if m.provider == prov]
+        for m in prov_models:
+            price_info = "**GRATUIT**" if m.is_free else f"In: ${m.pricing_prompt:.2f} / Out: ${m.pricing_completion:.2f}"
+            ctx_info = f"{int(m.context_length/1000)}k"
+            desc = m.description_fr.replace('\n', ' ') if m.description_fr else ""
+            md_content += f"- **{m.name or m.model_id}** (`{m.model_id}`)\n"
+            md_content += f"  - *Domaine :* {m.domain}\n"
+            md_content += f"  - *Prix (1M tokens) :* {price_info}\n"
+            md_content += f"  - *Contexte :* {ctx_info}\n"
+            md_content += f"  - *Description :* {desc}\n\n"
+
+    zip_io = io.BytesIO()
+    with zipfile.ZipFile(zip_io, mode='w', compression=zipfile.ZIP_DEFLATED) as zf:
+        zf.writestr("models_export.csv", csv_io.getvalue().encode('utf-8'))
+        zf.writestr(f"{datetime.now().strftime('%Y%m%d')}-extraction-modeles.md", md_content.encode('utf-8'))
+
+    zip_io.seek(0)
+    return Response(
+        content=zip_io.getvalue(), 
+        media_type="application/zip", 
+        headers={"Content-Disposition": f"attachment; filename=aethas38_models_{datetime.now().strftime('%Y%m%d')}.zip"}
+    )

backend/orchestrator.py

@@ -1,5 +1,6 @@
 import asyncio
 import httpx
+import urllib.parse
 from openai import AsyncOpenAI
 from fastapi import HTTPException
 from sqlalchemy.orm import Session
@@ -7,6 +8,16 @@ from sqlalchemy.exc import IntegrityError
 from .models import SystemSettings, AIModel, FinancialLog
 from datetime import datetime, timezone
 
+# --- LOGGER GLOBAL POUR LE TERMINAL ---
+activity_logs = []
+
+def log_activity(msg: str):
+    ts = datetime.now(timezone.utc).strftime('%H:%M:%S')
+    activity_logs.append(f"[{ts}] {msg}")
+    if len(activity_logs) > 100:
+        activity_logs.pop(0)
+# --------------------------------------
+
 def determine_domain(model_id: str) -> str:
     mid = model_id.lower()
     if "vision" in mid or "vl" in mid or "omni" in mid: return "Vision & Texte"
@@ -14,10 +25,21 @@ def determine_domain(model_id: str) -> str:
     if "audio" in mid or "whisper" in mid: return "Audio"
     return "Texte Polyvalent"
 
+async def translate_en_to_fr(client: httpx.AsyncClient, text: str) -> str:
+    if not text: return "Aucune description fournie."
+    try:
+        short_text = text[:300].strip()
+        url = f"https://translate.googleapis.com/translate_a/single?client=gtx&sl=en&tl=fr&dt=t&q={urllib.parse.quote(short_text)}"
+        resp = await client.get(url, timeout=4.0)
+        if resp.status_code == 200:
+            translated = "".join([s[0] for s in resp.json()[0]])
+            return translated + ("..." if len(text) > 300 else "")
+    except Exception:
+        pass
+    return text[:200] + "..."
+
 async def sync_finances(db: Session, settings: SystemSettings):
-    """Interroge les fournisseurs pour récupérer le solde financier exact."""
     async with httpx.AsyncClient(timeout=30.0) as client:
-        # OpenRouter
         if settings.openrouter_management_key or settings.openrouter_api_key:
             try:
                 key = settings.openrouter_management_key or settings.openrouter_api_key
@@ -38,10 +60,7 @@ async def sync_finances(db: Session, settings: SystemSettings):
                 update_finance_db(db, "OpenRouter", balance, usage)
             except Exception as e: print(f"Erreur Finance OR: {e}")
             
-        # Groq
         if settings.groq_api_key: update_finance_db(db, "Groq", 999.0, 0.0)
-            
-        # DeepSeek
         if settings.deepseek_api_key:
             try:
                 resp = await client.get("https://api.deepseek.com/user/balance", headers={"Authorization": f"Bearer {settings.deepseek_api_key}"})
@@ -49,11 +68,7 @@ async def sync_finances(db: Session, settings: SystemSettings):
                     infos = resp.json().get("balance_infos", [{}])[0]
                     update_finance_db(db, "DeepSeek", float(infos.get("total_balance", 0)), 0.0)
             except Exception: pass
-
-        # Mistral AI
         if settings.mistral_api_key: update_finance_db(db, "Mistral", 0.0, 0.0)
-        
-        # Gemini
         if settings.gemini_api_key: update_finance_db(db, "Gemini", 0.0, 0.0)
 
     try: db.commit()
@@ -69,12 +84,10 @@ def update_finance_db(db, provider, balance, usage):
     except Exception as e: print(f"Finance DB Error: {e}")
 
 async def sync_providers_models(db: Session, settings: SystemSettings, sync_type: str = "Automatique"):
+    log_activity(f"Lancement de la synchronisation des modèles ({sync_type})...")
     added = 0
-    # On stocke les modèles en mémoire avant de les envoyer en base pour éviter les doublons
     models_to_process = {}
-
     async with httpx.AsyncClient(timeout=90.0) as client:
-        # 1. OpenRouter
         if settings.openrouter_api_key:
             try:
                 resp = await client.get("https://openrouter.ai/api/v1/models")
@@ -84,95 +97,82 @@ async def sync_providers_models(db: Session, settings: SystemSettings, sync_type
                             m_id = item.get("id")
                             if not m_id: continue
                             pricing = item.get("pricing") or {}
-                            try: pp = float(pricing.get("prompt") or 0.0) * 1000000
+                            pp = float(pricing.get("prompt") or 0.0) * 1000000
-                            except: pp = 0.0
+                            pc = float(pricing.get("completion") or 0.0) * 1000000
-                            try: pc = float(pricing.get("completion") or 0.0) * 1000000
-                            except: pc = 0.0
                             is_free = (pp == 0.0 and pc == 0.0)
-                            desc = item.get("description", "Modèle OpenRouter.")[:200] + "..."
+                            desc_en = item.get("description", "Generic AI Model.")
-                            models_to_process[m_id] = {"provider": "openrouter", "name": item.get("name", "Inconnu"), "desc": desc, "domain": determine_domain(m_id), "is_free": is_free, "ctx": item.get("context_length", 0), "pp": pp, "pc": pc}
+                            models_to_process[m_id] = {"provider": "openrouter", "name": item.get("name", "Inconnu"), "desc_en": desc_en, "domain": determine_domain(m_id), "is_free": is_free, "ctx": item.get("context_length", 0), "pp": pp, "pc": pc}
                         except: pass
             except Exception as e: print(f"Erreur OR Models: {e}")
             
-        # 2. Groq
         if settings.groq_api_key:
             try:
                 resp = await client.get("https://api.groq.com/openai/v1/models", headers={"Authorization": f"Bearer {settings.groq_api_key}"})
                 if resp.status_code == 200:
                     for item in resp.json().get("data", []):
-                        try:
+                        m_id = item["id"]
-                            m_id = item["id"]
+                        models_to_process[m_id] = {"provider": "groq", "name": m_id.capitalize(), "desc": "Modèle très rapide hébergé sur LPU Groq.", "domain": determine_domain(m_id), "is_free": True, "ctx": 8192, "pp": 0.0, "pc": 0.0}
-                            models_to_process[m_id] = {"provider": "groq", "name": m_id.capitalize(), "desc": "Modèle rapide LPU Groq.", "domain": determine_domain(m_id), "is_free": True, "ctx": 8192, "pp": 0.0, "pc": 0.0}
-                        except: pass
             except Exception: pass
 
-        # 3. DeepSeek
         if settings.deepseek_api_key:
             try:
                 resp = await client.get("https://api.deepseek.com/models", headers={"Authorization": f"Bearer {settings.deepseek_api_key}"})
                 if resp.status_code == 200:
                     for item in resp.json().get("data", []):
-                        try:
+                        m_id = item["id"]
-                            m_id = item["id"]
+                        models_to_process[m_id] = {"provider": "deepseek", "name": m_id.capitalize(), "desc": "Modèle officiel du fournisseur DeepSeek.", "domain": determine_domain(m_id), "is_free": False, "ctx": 64000, "pp": 0.14, "pc": 0.28}
-                            models_to_process[m_id] = {"provider": "deepseek", "name": m_id.capitalize(), "desc": "Modèle officiel DeepSeek.", "domain": determine_domain(m_id), "is_free": False, "ctx": 64000, "pp": 0.14, "pc": 0.28}
-                        except: pass
             except Exception: pass
 
-        # 4. Mistral
         if settings.mistral_api_key:
             try:
                 resp = await client.get("https://api.mistral.ai/v1/models", headers={"Authorization": f"Bearer {settings.mistral_api_key}"})
                 if resp.status_code == 200:
                     for item in resp.json().get("data", []):
-                        try:
+                        m_id = item["id"]
-                            m_id = item["id"]
+                        models_to_process[m_id] = {"provider": "mistral", "name": m_id.capitalize(), "desc": "Modèle officiel développé par Mistral AI.", "domain": determine_domain(m_id), "is_free": False, "ctx": 32000, "pp": 0.2, "pc": 0.6}
-                            models_to_process[m_id] = {"provider": "mistral", "name": m_id.capitalize(), "desc": "Modèle officiel Mistral AI.", "domain": determine_domain(m_id), "is_free": False, "ctx": 32000, "pp": 0.2, "pc": 0.6}
-                        except: pass
             except Exception: pass
 
-        # 5. Gemini (Google)
         if settings.gemini_api_key:
             try:
                 resp = await client.get(f"https://generativelanguage.googleapis.com/v1beta/models?key={settings.gemini_api_key}")
                 if resp.status_code == 200:
                     for item in resp.json().get("models", []):
-                        try:
+                        m_id = item["name"].replace("models/", "")
-                            m_id = item["name"].replace("models/", "")
+                        models_to_process[m_id] = {"provider": "gemini", "name": item.get("displayName", m_id), "desc": "Modèle natif de l'écosystème Google Gemini.", "domain": determine_domain(m_id), "is_free": True, "ctx": item.get("inputTokenLimit", 32000), "pp": 0.0, "pc": 0.0}
-                            desc = item.get("description", "Modèle Google Gemini.")[:200] + "..."
-                            models_to_process[m_id] = {"provider": "gemini", "name": item.get("displayName", m_id), "desc": desc, "domain": determine_domain(m_id), "is_free": True, "ctx": item.get("inputTokenLimit", 32000), "pp": 0.0, "pc": 0.0}
-                        except: pass
             except Exception: pass
 
-        # 6. Cloudflare
         if settings.cloudflare_account_id and settings.cloudflare_api_token:
             try:
                 url = f"https://api.cloudflare.com/client/v4/accounts/{settings.cloudflare_account_id}/ai/models/search"
                 resp = await client.get(url, headers={"Authorization": f"Bearer {settings.cloudflare_api_token}"})
                 if resp.status_code == 200:
                     for item in resp.json().get("result", []):
-                        try:
+                        m_id = item.get("name")
-                            m_id = item.get("name")
+                        models_to_process[m_id] = {"provider": "cloudflare", "name": m_id.split("/")[-1], "desc": "Modèle Serverless Cloudflare Workers AI.", "domain": determine_domain(m_id), "is_free": True, "ctx": 4096, "pp": 0.0, "pc": 0.0}
-                            desc = item.get("description", "Modèle Cloudflare Workers AI.")[:200] + "..."
-                            models_to_process[m_id] = {"provider": "cloudflare", "name": m_id.split("/")[-1], "desc": desc, "domain": determine_domain(m_id), "is_free": True, "ctx": 4096, "pp": 0.0, "pc": 0.0}
-                        except: pass
             except Exception: pass
 
-    # --- Phase d'enregistrement sécurisée ---
+    sem = asyncio.Semaphore(15)
-    for m_id, data in models_to_process.items():
+    async def process_and_translate(m_id, data, client_session):
+        async with sem:
+            if "desc_en" in data:
+                data["desc"] = await translate_en_to_fr(client_session, data["desc_en"])
+            return m_id, data
+
+    async with httpx.AsyncClient(timeout=30.0) as client_trans:
+        tasks = [process_and_translate(m_id, data, client_trans) for m_id, data in models_to_process.items()]
+        translated_results = await asyncio.gather(*tasks)
+
+    for m_id, data in translated_results:
         try:
             existing = db.query(AIModel).filter(AIModel.model_id == m_id).first()
             if existing:
-                existing.pricing_prompt = data["pp"]; existing.pricing_completion = data["pc"]; existing.is_free = data["is_free"]; existing.last_updated = datetime.now(timezone.utc)
+                existing.pricing_prompt = data["pp"]; existing.pricing_completion = data["pc"]; existing.is_free = data["is_free"]; existing.description_fr = data["desc"]; existing.last_updated = datetime.now(timezone.utc)
             else:
                 db.add(AIModel(provider=data["provider"], model_id=m_id, name=data["name"], description_fr=data["desc"], domain=data["domain"], is_free=data["is_free"], context_length=data["ctx"], pricing_prompt=data["pp"], pricing_completion=data["pc"]))
             added += 1
-            # Commit très fréquent pour éviter les gros blocs qui plantent
+            if added % 50 == 0: db.commit()
-            if added % 50 == 0:
+        except IntegrityError: db.rollback()
-                db.commit()
+        except Exception: db.rollback()
-        except IntegrityError:
-            db.rollback() # Si conflit, on annule cette insertion et on continue
-        except Exception:
-            db.rollback()
 
     try:
         settings.last_sync_date = datetime.now(timezone.utc)
@@ -180,13 +180,12 @@ async def sync_providers_models(db: Session, settings: SystemSettings, sync_type
         db.commit()
     except Exception as e:
         db.rollback()
-        print(f"Erreur DB Commit Sync: {e}")
         
     await sync_finances(db, settings)
+    log_activity(f"Synchronisation terminée : {added} modèles analysés.")
     return {"status": "success", "models_processed": added}
 
 def get_client_for_model(db: Session, model_id: str, settings: SystemSettings):
-    """Récupère dynamiquement le bon client OpenAI en fonction du fournisseur du modèle."""
     model_db = db.query(AIModel).filter(AIModel.model_id == model_id).first()
     provider = model_db.provider if model_db else "openrouter"
 
@@ -207,38 +206,111 @@ async def ask_agent(client, model_id, messages, provider="openrouter"):
     kwargs = {"model": model_id, "messages": messages}
     if provider == "openrouter": 
         kwargs["extra_headers"] = {"HTTP-Referer": "https://aethas38.duckdns.org", "X-Title": "AETHAS38 Orchestrator"}
+        # Activation native du plugin web-search et de compression
+        kwargs["extra_body"] = {"plugins": [{"id": "context-compression"}, {"id": "web-search"}]}
+        
     resp = await client.chat.completions.create(**kwargs)
     return resp.choices[0].message.content
 
-async def run_orchestrator(db: Session, history: list, settings: SystemSettings, config: dict) -> str:
+async def run_orchestrator(db: Session, history: list, settings: SystemSettings, config: dict, extracted_files: list = None) -> str:
     workers = config.get("workers", ["gemini-3.5-flash-lite"])
     user_prompt = history[-1].content
+    original_user_text = user_prompt.split("\n\n[Fichiers joints")[0] if "[Fichiers joints" in user_prompt else user_prompt
     formatted_history = [{"role": msg.role, "content": msg.content} for msg in history[:-1]]
 
     final_response = ""
     try:
+        p_mod = config.get("prompter")
+        if not p_mod: p_mod = "gemini-3.5-flash-lite"
+        
+        log_activity(f"Démarrage de l'orchestration. Modèle Prompteur: {p_mod}")
+        p_client, p_prov = get_client_for_model(db, p_mod, settings)
+
+        files_context = ""
+        if extracted_files:
+            log_activity(f"Traitement Map-Reduce de {len(extracted_files)} fichier(s) joint(s).")
+            async def process_single_file(f):
+                file_sys = "You are an expert data analyst and senior developer. Extract the most important technical information from the file without losing critical code syntax."
+                content = f['content']
+                chunk_size = 150000 
+                
+                if len(content) > chunk_size:
+                    chunks = [content[i:i+chunk_size] for i in range(0, len(content), chunk_size)]
+                    chunk_analyses = []
+                    log_activity(f"Fichier lourd ({f['name']}): Chunking en {len(chunks)} morceaux.")
+                    for idx, chunk in enumerate(chunks):
+                        file_prompt = f"Demande de l'utilisateur : '{original_user_text}'.\n\nPartie {idx+1}/{len(chunks)} du fichier '{f['name']}'. Analysez, extrayez et résumez le code, VBA, SQL ou les données pertinentes.\n\nContenu :\n```\n{chunk}\n```"
+                        try:
+                            analysis = await ask_agent(p_client, p_mod, [{"role": "system", "content": file_sys}, {"role": "user", "content": file_prompt}], p_prov)
+                            chunk_analyses.append(analysis)
+                            log_activity(f"Analyse chunk {idx+1}/{len(chunks)} pour {f['name']} réussie.")
+                        except Exception as e:
+                            chunk_analyses.append(f"[Erreur sur la partie {idx+1}: {str(e)}]")
+                            log_activity(f"Erreur chunk {idx+1}/{len(chunks)} pour {f['name']}: {str(e)}")
+                        
+                        await asyncio.sleep(1.5) 
+                    
+                    return f"\n\n--- Extraction du fichier {f['name']} (en {len(chunks)} parties) ---\n" + "\n".join(chunk_analyses)
+                else:
+                    file_prompt = f"Demande de l'utilisateur : '{original_user_text}'.\n\nAnalysez le fichier ci-dessous. Extrayez, résumez et conservez méticuleusement tout le code, les macros VBA, les requêtes SQL, ou les données métier pertinentes pour répondre à la demande.\n\nFichier : {f['name']}\nContenu :\n```\n{content}\n```"
+                    try:
+                        analysis = await ask_agent(p_client, p_mod, [{"role": "system", "content": file_sys}, {"role": "user", "content": file_prompt}], p_prov)
+                        log_activity(f"Analyse intégrale de {f['name']} réussie.")
+                        return f"\n\n--- Extraction du fichier {f['name']} ---\n{analysis}"
+                    except Exception as e:
+                        log_activity(f"Erreur d'analyse sur {f['name']}: {str(e)}")
+                        return f"\n\n--- Erreur sur {f['name']} ---\n{str(e)}"
+
+            file_analyses = []
+            for f in extracted_files:
+                analysis = await process_single_file(f)
+                file_analyses.append(analysis)
+                await asyncio.sleep(1.5)
+            
+            files_context = "".join(file_analyses)
+            user_prompt = f"{original_user_text}\n\nVoici les données pré-traitées des fichiers joints :\n{files_context}"
+
+        log_activity(f"Optimisation/Traduction de la requête via Prompteur...")
+        prompt_system = "You are an expert prompt engineer. Translate and optimize the user request and any file context into clear, precise English tailored for AI execution. Keep all code blocks intact."
+        optimized = await ask_agent(p_client, p_mod, [{"role": "system", "content": prompt_system}, {"role": "user", "content": user_prompt}], p_prov)
+
+        log_activity(f"Lancement de {len(workers)} travailleur(s) en parallèle...")
         if len(workers) == 1:
             w_mod = workers[0]
             client, provider = get_client_for_model(db, w_mod, settings)
-            final_response = await ask_agent(client, w_mod, formatted_history + [{"role": "user", "content": user_prompt}], provider)
+            worker_response = await ask_agent(client, w_mod, formatted_history + [{"role": "user", "content": optimized}], provider)
+            responses = [worker_response]
+            log_activity(f"Travailleur 1 ({w_mod}) a terminé.")
         else:
-            p_mod = config.get("prompter", "gemini-3.5-flash-lite")
-            p_client, p_prov = get_client_for_model(db, p_mod, settings)
-            optimized = await ask_agent(p_client, p_mod, [{"role": "system", "content": "Optimise cette requête."}, {"role": "user", "content": user_prompt}], p_prov)
-
             w_tasks = []
             for w in workers:
                 w_client, w_prov = get_client_for_model(db, w, settings)
                 w_tasks.append(ask_agent(w_client, w, formatted_history + [{"role": "user", "content": optimized}], w_prov))
-                
             responses = await asyncio.gather(*w_tasks, return_exceptions=True)
+            log_activity("Tous les travailleurs ont terminé leur analyse.")
+
+        c_mod = config.get("concatenator")
+        if not c_mod: c_mod = "gemini-3.5-flash-lite"
+        
+        c_client, c_prov = get_client_for_model(db, c_mod, settings)
+        
+        log_activity(f"Synthèse et traduction finale via Concaténeur ({c_mod})...")
+        concat_system = (
+            "You are a master lead developer and technical synthesizer. "
+            "Synthesize the provided expert responses into a single cohesive response. "
+            "Translate all explanatory text, descriptions, and user-facing prose into natural French. "
+            "CRITICAL: Do NOT translate code blocks, programming keywords, or source code contents. "
+            "You may translate code comments into French if appropriate, but leave code syntax strictly intact."
+        )
+        
+        synth = f"User Request: {original_user_text}\n\n" + "\n".join([f"--- EXPERT {i+1} ---\n{str(r)}" for i, r in enumerate(responses)])
+        final_response = await ask_agent(c_client, c_mod, [{"role": "system", "content": concat_system}, {"role": "user", "content": synth}], c_prov)
+        
+        log_activity("Orchestration terminée avec succès.")
 
-            c_mod = config.get("concatenator", "gemini-3.5-flash-lite")
-            c_client, c_prov = get_client_for_model(db, c_mod, settings)
-            synth = f"Requête: {user_prompt}\n\n" + "\n".join([f"--- EXPERT {i+1} ---\n{r}" for i, r in enumerate(responses)]) + "\n\nFais une synthèse finale."
-            final_response = await ask_agent(c_client, c_mod, [{"role": "user", "content": synth}], c_prov)
     except Exception as e:
         final_response = f"L'IA a rencontré une erreur critique: {str(e)}"
+        log_activity(f"ERREUR CRITIQUE: {str(e)}")
     
     await sync_finances(db, settings)
     return final_response

backend/schemas.py

@@ -20,6 +20,26 @@ class AdminCreate(BaseModel):
     cloudflare_api_token: Optional[str] = None
     huggingface_api_key: Optional[str] = None
 
+class SystemSettingsBase(BaseModel):
+    smtp_host: Optional[str] = None
+    smtp_port: Optional[int] = None
+    smtp_user: Optional[str] = None
+    smtp_password: Optional[str] = None
+    openrouter_api_key: Optional[str] = None
+    openrouter_management_key: Optional[str] = None
+    groq_api_key: Optional[str] = None
+    gemini_api_key: Optional[str] = None
+    deepseek_api_key: Optional[str] = None
+    mistral_api_key: Optional[str] = None
+    cloudflare_account_id: Optional[str] = None
+    cloudflare_api_token: Optional[str] = None
+    huggingface_api_key: Optional[str] = None
+
+class SystemSettingsUpdate(SystemSettingsBase): pass
+
+class SystemSettingsResponse(SystemSettingsBase):
+    class Config: from_attributes = True
+
 class LoginRequest(BaseModel):
     username: str
     password: str
@@ -44,12 +64,17 @@ class OrchestratorConfig(BaseModel):
     prompter: Optional[str] = "gemini-3.5-flash-lite"
     concatenator: Optional[str] = "gemini-3.5-flash-lite"
 
+class AttachedFile(BaseModel):
+    name: str
+    content: str
+
 class MessageBase(BaseModel):
     role: str
     content: str
 
 class MessageCreate(MessageBase):
     config: Optional[OrchestratorConfig] = None
+    files: Optional[List[AttachedFile]] = None
 
 class MessageResponse(MessageBase):
     id: int
@@ -60,3 +85,9 @@ class MessageResponse(MessageBase):
 class PasswordChange(BaseModel):
     old_password: str
     new_password: str
+
+class ModelReplacementRequest(BaseModel):
+    missing_model: str
+
+class LogRequest(BaseModel):
+    message: str

requirements.txt

@@ -15,3 +15,6 @@ openai
 httpx
 python-multipart
 pytz
+PyPDF2
+openpyxl
+oletools