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

README.md

@@ -5,65 +5,78 @@ Ce projet est un laboratoire d'intelligence artificielle personnel. Il agit comm
 L'interface visuelle est inspirée de l'ergonomie de Gemini, avec le logo stylisé A38 (cerveau en réseau neuronal néon) comme charte graphique centrale.
 
 ## 🏗️ Stack Technique & Architecture
-- **Backend :** FastAPI (Python) modulaire et asynchrone (httpx, asyncio).
+
-- **Frontend :** Vue.js + Tailwind CSS (Responsive / Mobile-first).
+* **Backend :** FastAPI (Python) modulaire asynchrone (httpx, asyncio)[cite: 2].
-- **Base de Données :** PostgreSQL (gestion des utilisateurs, historiques, suivi financier, rôles hiérarchiques).
+* **Frontend :** Vue.js + Tailwind CSS (Responsive / Mobile-first)[cite: 2].
-- **Traitement Documentaire :** LibreOffice Headless (génération/conversion Excel, Word, PDF).
+* **Base de Données :** PostgreSQL (gestion des utilisateurs, rôles hiérarchiques Super-Admin/Admin/User, historiques, suivi financier)[cite: 2].
-- **Déploiement :** Docker, géré via Dockge et Gitea, sécurisé sur grappe RAID.
+* **Traitement Documentaire :** LibreOffice Headless (génération/conversion Excel, Word, PDF)[cite: 2].
+* **Déploiement :** Docker, géré via Dockge et Gitea, sécurisé sur grappe RAID[cite: 2].
 
 ## 📌 Règles de Versioning (SemVer)
-Le développement suit un versioning strict (format `vX.Y.Z`) synchronisé avec les tags Gitea et GitHub, affiché dynamiquement sur l'interface :
+
-- **Majeur (X) :** Changement profond d'architecture ou refonte globale.
+Le développement suit un versioning strict (format `vX.Y.Z`) synchronisé avec les tags Gitea et GitHub, affiché dynamiquement sur l'interface[cite: 2]:
-- **Mineur (Y) :** Validation et ajout d'une nouvelle fonctionnalité de la roadmap.
+
-- **Patch (Z) :** Corrections de bugs, correctifs de sécurité ou ajustements visuels mineurs.
+* **Majeur (X) :** Changement profond d'architecture ou refonte globale[cite: 2].
+* **Mineur (Y) :** Validation et ajout d'une nouvelle fonctionnalité de la roadmap[cite: 2].
+* **Patch (Z) :** Corrections de bugs, correctifs de sécurité ou ajustements visuels mineurs[cite: 2].
 
 ## 📦 Récupération des Paquets Docker (Tags)
-Les images Docker sont construites automatiquement par les pipelines CI/CD lors de la création d'un tag.
+
-- **Sur Gitea :** Depuis la page principale de votre dépôt, naviguez dans l'onglet **Packages** (ou Paquets). Vous y trouverez le registre de conteneurs avec toutes les versions taguées (`v0.16.0`, `latest`, etc.).
+Les images Docker sont construites automatiquement par les pipelines CI/CD lors de la création d'un tag[cite: 2].
-- **Sur GitHub :** Depuis la page principale du dépôt, regardez dans la colonne de droite la section **Packages**. Cliquez dessus pour accéder au GitHub Container Registry (`ghcr.io/votre-utilisateur/aethas38-multi-ia`) et visualiser la liste des tags disponibles à tirer via Docker/Dockge.
+
+* **Sur Gitea :** Depuis la page principale de votre dépôt, naviguez dans l'onglet **Packages** (ou Paquets). Vous y trouverez le registre de conteneurs avec toutes les versions taguées (`v0.16.1`, `latest`, etc.)[cite: 2].
+* **Sur GitHub :** Depuis la page principale du dépôt, regardez dans la colonne de droite la section **Packages**. Cliquez dessus pour accéder au GitHub Container Registry (`ghcr.io/votre-utilisateur/aethas38-multi-ia`) et visualiser la liste des tags disponibles à tirer via Docker/Dockge[cite: 2].
 
 ## 🚀 ROADMAP & CAHIER DES CHARGES
 
 ### Sécurité & Infrastructure
-- [x] Installation stricte via Dockge et Gitea (création automatique des dossiers inclus).
+
-- [x] Sécurisation de la totalité du projet (fichiers, BDD PostgreSQL) sur le stockage RAID.
+* [x] Installation stricte via Dockge et Gitea (création automatique des dossiers inclus)[cite: 2].
-- [x] Mots de passe cryptés (bcrypt), protection anti-brute force.
+* [x] Sécurisation de la totalité du projet (fichiers, BDD PostgreSQL) sur le stockage RAID[cite: 2].
-- [x] Authentification 2FA obligatoire (Keepassium, Authenticator, etc.).
+* [x] Mots de passe cryptés (bcrypt), protection anti-brute force[cite: 2].
-- [x] Déconnexion automatique (timer invisible / session JWT) après 60 minutes d'inactivité.
+* [x] Authentification 2FA obligatoire (Keepassium, Authenticator, etc.)[cite: 2].
-- [x] Configuration de GitHub Actions / Gitea Actions pour la création automatique des paquets Docker (Tags SemVer + latest).
+* [x] Déconnexion automatique (timer invisible / session JWT) après 60 minutes d'inactivité[cite: 2].
-- [x] Horodatage UTC en base de données pour immunité au changement d'heure français (Prévention crash 2FA).
+* [x] Configuration de GitHub Actions / Gitea Actions pour la création automatique des paquets Docker (Tags SemVer + latest)[cite: 2].
-- [x] Rotation automatique des logs système : génération d'un fichier log par jour avec purge stricte des fichiers de plus de 7 jours.
+* [x] Horodatage UTC en base de données pour immunité au changement d'heure français (Prévention crash 2FA)[cite: 2].
-- [x] Procédure de modification sécurisée du mot de passe (Utilisateurs et Admins).
+* [x] Rotation automatique des logs système : génération d'un fichier log par jour avec purge stricte des fichiers de plus de 7 jours[cite: 2].
+* [x] Procédure de modification sécurisée du mot de passe (Utilisateurs et Admins)[cite: 2].
 
 ### Administration & Gestion des Utilisateurs
-- [x] Assistant de première installation : le premier utilisateur initiateur devient automatiquement le **Super-Admin** unique du projet.
+
-- [x] Refonte du setup initial (Super-Admin) : configuration du serveur mail (opérateurs FR/Gmail) et paramétrage complet des clés fournisseurs IA.
+* [x] Assistant de première installation : l'initiateur du projet se voit attribuer automatiquement le rôle exclusif de **Super-Admin** (un seul par projet)[cite: 2].
-- [x] Intégration de la roue crantée (Paramètres) en bas de la barre latérale.
+* [x] Refonte du setup initial (Super Admin) : configuration du serveur mail (opérateurs FR/Gmail) et paramétrage complet des clés fournisseurs IA[cite: 2].
-- [x] Page de configuration par niveau (Super-Admin, Admin, Utilisateur).
+* [x] Intégration de la roue crantée (Paramètres) en bas de la barre latérale[cite: 2].
-- [x] Upload et personnalisation d'avatar utilisateur (redimensionnement et adaptation dynamique).
+* [x] Page de configuration par niveau (Super-Admin, Admin, Utilisateur)[cite: 2].
-- [ ] Hiérarchie des rôles : Un Admin peut proposer l'élévation d'un User en Admin (soumis à validation exclusive du Super-Admin).
+* [x] Upload et personnalisation dynamique d'avatar utilisateur[cite: 2].
-- [ ] Export de l'activité Admin : Fichier Excel avec KPI, graphiques "camembert", et suivi financier par utilisateur.
+* [ ] Hiérarchie des rôles : Un Admin peut proposer l'élévation d'un User en Admin (formulaire soumis à la validation exclusive du Super Admin)[cite: 2].
-- [ ] Envoi de rapport d'activité automatisé chaque jeudi à 04h00.
+* [ ] Export de l'activité Admin : Fichier Excel avec KPI, graphiques "camembert", et suivi financier par utilisateur[cite: 2].
+* [x] Suivi financier en temps réel et vérification du budget API (mis à jour après chaque requête et affiché de manière non invasive sous le nom)[cite: 2].
+* [ ] Envoi de rapport d'activité automatisé chaque jeudi à 04h00[cite: 2].
 
 ### Expérience Utilisateur (UI/UX)
-- [x] Thème moderne (Gemini-like) et 100% compatible smartphones.
+
-- [x] Refonte de la gestion des projets : séparation Épinglés (en haut) / Non Épinglés (Récents).
+* [x] Thème moderne (Gemini-like) et 100% compatible smartphones[cite: 2].
-- [x] Arrêt de la création automatique de nouveau projet à l'ouverture.
+* [x] Refonte de la gestion des projets : séparation Épinglés (en haut) / Non Épinglés (Récents)[cite: 2].
-- [x] Intégration permanente du logo AETHAS38 en local (Setup / Login / Dashboard).
+* [x] Arrêt de la création automatique de nouveau projet à l'ouverture[cite: 2].
-- [x] Indicateur visuel (Loader/Animation) signalant que l'IA AETHAS38 "réfléchit" ou travaille.
+* [x] Intégration permanente du logo AETHAS38 en local (Setup / Login / Dashboard)[cite: 2].
-- [x] Fonctionnalité de renommage manuel des discussions/projets.
+* [x] Indicateur visuel (Loader/Animation) signalant que l'IA AETHAS38 "réfléchit" ou travaille[cite: 2].
-- [x] Affichage permanent et non invasif des soldes financiers fournisseurs sous le profil utilisateur, mis à jour après chaque requête.
+* [x] Fonctionnalité de renommage manuel des discussions/projets[cite: 2].
-- [ ] Affichage natif et fluide des images directement dans le flux de la discussion.
+* [ ] Affichage natif et fluide des images directement dans le flux de la discussion[cite: 2].
-- [ ] Système de partage des réponses sur les réseaux et messageries externes (Facebook, WhatsApp, etc.).
+* [ ] Système de partage des réponses sur les réseaux et messageries externes (Facebook, WhatsApp, etc.)[cite: 2].
 
 ### Moteur IA, Modèles & Fonctionnalités
-- [x] Cœur asynchrone pour la parallélisation des appels API (module `orchestrator.py`).
+
-- [x] Pipeline multi-agents complet avec sélection dynamique par requête :
+* [x] Cœur asynchrone pour la parallélisation des appels API (module `orchestrator.py`)[cite: 2].
-  - Sélection de 1 à 5 travailleurs IA en parallèle.
+* [x] Pipeline multi-agents complet avec sélection dynamique par requête :
-  - Si 1 seul travailleur : bypass automatique du prompteur et du concaténeur.
+  * Sélection de 1 à 5 travailleurs IA en parallèle[cite: 2].
-  - Si > 1 travailleur : chaîne complète active (1 Prompteur ➔ N Travailleurs ➔ 1 Concaténeur).
+  * Si un seul travailleur est sélectionné, bypass automatique du prompteur et du concaténeur[cite: 2].
-- [x] Extraction universelle et multi-fournisseurs (OpenRouter, Groq, DeepSeek, Mistral, Gemini, Cloudflare) avec timeout étendu à 90 secondes.
+  * Si > 1 travailleur, activation de la chaîne complète (1 Prompteur ➔ N Travailleurs ➔ 1 Concaténeur)[cite: 2].
-- [x] Tâche planifiée (CRON) pour la mise à jour automatique des modèles toutes les 12h (00h00 et 12h00 heure de Paris).
+* [x] Extraction universelle multi-fournisseurs (OpenRouter, Groq, DeepSeek, Mistral, Gemini, Cloudflare) avec timeout porté à 90 secondes[cite: 2].
-- [x] Page dédiée aux modèles : export, import manuel de fichiers d'extraction JSON, filtrage par prix (Gratuit/Payant), domaine (Code, Texte, Vision, Audio) et recherche textuelle.
+* [x] Tâche planifiée (CRON) pour la mise à jour des modèles toutes les 12h (00h00 et 12h00)[cite: 2].
-- [x] Extraction unitaire des retours IA et téléchargement global d'une conversation (formats TXT et JSON).
+* [x] Page spécifique dédiée aux modèles permettant l'export, l'import manuel d'un fichier d'extraction JSON, ainsi que le filtrage par prix, domaine et mots-clés[cite: 2].
-- [x] Détection et téléchargement ciblé de blocs de code ou de données (ex: fichiers `.xlsx`, `.py`, `.csv`) générés par l'IA en respectant le nommage exact.
+* [x] Extraction unitaire des retours IA et téléchargement global d'une conversation (formats TXT et JSON)[cite: 2].
+* [x] Détection et téléchargement ciblé de pièces jointes ou blocs spécifiques (Code brut, scripts, fichiers de données) générés par l'IA en respectant le nommage exact demandé[cite: 2].
+* [x] Classement, filtrage (Gratuit/Payant) et catégorisation des modèles (Texte, Code, Vision, Audio)[cite: 2].
+* [ ] Traduction automatisée des descriptions des modèles via Ollama (local) ou Gemini[cite: 2].
+* [ ] Interface d'aide à la décision pour le choix des modèles selon la tâche souhaitée[cite: 2].
+* [ ] Mécanisme de fallback / termes génériques pour les appels API (protection contre le dépassement des quotas)[cite: 2].

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