Spaces:
Running
Running
| """ | |
| WIDGET JASMINE LEGER PAR MODULE | |
| ================================= | |
| Assistant IA reutilisable, integrable sur n'importe quelle page. Contrairement | |
| a l'agent JASMINE global (src/modules/jasmine_agent.py, page Ontology), ce | |
| widget n'utilise PAS le moteur RDF/SPARQL (trop couteux a construire pour un | |
| usage ponctuel par page) : il s'appuie uniquement sur le client LLM centralise | |
| (src/core/llm_client.py) et les outils de calcul partages | |
| (src/agent/calc_tools.py), avec pour seul contexte les donnees deja chargees | |
| par la page appelante. | |
| """ | |
| import json | |
| import re | |
| import streamlit as st | |
| from core.llm_client import call_llm, LLMUnavailableError | |
| from core import exercice as ex | |
| from core import graphiques_contexte | |
| from agent.calc_tools import TOOL_FUNCTIONS, TOOL_DESCRIPTIONS | |
| _ALLOWED_ARGS = {"n_months", "horizon_weeks", "n_runs", "dossier"} | |
| def _build_system_prompt(scope_label, context_data, actions, allowed_tool_names): | |
| tools_txt = "\n".join(f"- {name} : {desc}" for name, desc in TOOL_DESCRIPTIONS.items() if name in allowed_tool_names) | |
| if actions: | |
| tools_txt += "\n" + "\n".join(f"- {name} : {meta['description']}" for name, meta in actions.items()) | |
| context_json = json.dumps(context_data, ensure_ascii=False, indent=2, default=str) | |
| actions_note = ( | |
| "Certains outils ci-dessus AGISSENT reellement sur cette page (ils relancent un " | |
| "calcul et mettent a jour ce que l'utilisateur voit a l'ecran), en plus des outils " | |
| "de calcul en lecture seule. Utilise-les si l'utilisateur demande explicitement " | |
| "de faire/relancer/mettre a jour quelque chose." | |
| if actions else "" | |
| ) | |
| return f"""ROLE: Tu es JASMINE, l'assistant IA de VORTEX, limité aux données de cette page. | |
| PORTÉE: {scope_label}. Tu ne connais QUE les données ci-dessous — pas d'accès | |
| à l'ontologie globale, ni aux données d'autres clients. | |
| {ex.consigne_ia()} | |
| DONNÉES DE LA PAGE : | |
| {context_json} | |
| OUTILS DISPONIBLES (optionnels, à utiliser seulement si nécessaire) : | |
| {tools_txt} | |
| {actions_note} | |
| Réponds aux questions en te basant uniquement sur les données ci-dessus. Sois direct | |
| et factuel, sans familiarité excessive — ce n'est pas une conversation avec un enfant. | |
| CONTRÔLES ET HYPOTHÈSES : les lignes "controle" de texte_affiche_a_l_ecran sont les cases, | |
| curseurs, listes et boutons de la page, avec leur état actuel. Pour une question « et si je | |
| coche / change / accepte X ? », explique ce que ce contrôle modifie d'après guide_page, les | |
| définitions et les formules, et chiffre l'effet avec les valeurs fournies (scénarios déjà | |
| calculés inclus). Ne réponds jamais seulement « je n'ai pas l'information » quand le guide ou | |
| les valeurs permettent de raisonner ; si une donnée précise manque, nomme-la. | |
| FORMAT JSON STRICT : | |
| {{ "reponse": "ta réponse ici si aucun outil n'est nécessaire, sinon chaîne vide", "tool": "nom_outil ou none", "args": {{}} }} | |
| """ | |
| def render_scoped_widget(client, sheet_name, scope_label: str, context_data: dict, key_prefix: str, actions: dict = None, allowed_tools: list = None): | |
| """Affiche un expander de chat JASMINE scopé aux données de la page appelante. | |
| actions (optionnel) : {"nom_action": {"fn": callable(**args) -> dict, "description": str}} | |
| — des outils propres à la page appelante qui AGISSENT réellement (relancent un calcul, | |
| mettent à jour st.session_state) plutôt que de se contenter de calculer une réponse. | |
| La fonction est appelée directement (thread principal Streamlit) et son résultat doit | |
| être un dict JSON-sérialisable ; le widget déclenche un st.rerun() après coup pour que | |
| la page reflète le changement. | |
| allowed_tools (optionnel) : liste blanche des noms d'outils de calc_tools.py autorisés | |
| sur cette page. None (défaut) = tous les outils, pour les pages internes authentifiées. | |
| Une page publique/non authentifiée doit passer une liste explicite (potentiellement | |
| vide []) — le LLM ne doit jamais décider seul de l'accès a des donnees hors du scope | |
| de cette page ; le filtrage se fait cote Python, pas seulement via le system prompt.""" | |
| actions = actions or {} | |
| # Graphiques affiches sur cette page (captes par core/graphiques_contexte.py) : le chat les lit. | |
| graphiques = graphiques_contexte.pour_page(st.session_state.get("_audit_menu", "")) | |
| if graphiques: | |
| context_data = {**context_data, "graphiques_affiches": graphiques} | |
| # Texte affiche sur la page (recommandations, valeurs, alertes, tableaux) : ce que l'utilisateur lit. | |
| affichage = graphiques_contexte.texte_page(st.session_state.get("_audit_menu", "")) | |
| if affichage: | |
| context_data = {**context_data, "texte_affiche_a_l_ecran": affichage} | |
| allowed_tool_names = set(TOOL_FUNCTIONS.keys()) if allowed_tools is None else set(allowed_tools) & set(TOOL_FUNCTIONS.keys()) | |
| history_key = f"{key_prefix}_jasmine_chat" | |
| if history_key not in st.session_state: | |
| st.session_state[history_key] = [] | |
| with st.expander("Demander à JASMINE (assistant limité aux données de cette page)", expanded=False): | |
| for msg in st.session_state[history_key]: | |
| with st.chat_message(msg["role"]): | |
| st.code(msg["content"], language=None, wrap_lines=True) | |
| prompt = st.chat_input("Poser une question...", key=f"{key_prefix}_jasmine_input") | |
| if not prompt: | |
| return | |
| st.session_state[history_key].append({"role": "user", "content": prompt}) | |
| system_prompt = _build_system_prompt(scope_label, context_data, actions, allowed_tool_names) | |
| messages = [{"role": "system", "content": system_prompt}] | |
| messages.extend(st.session_state[history_key][-6:]) | |
| try: | |
| with st.spinner("JASMINE réfléchit..."): | |
| texte = call_llm(messages, json_mode=True, temperature=0.2) | |
| clean = re.sub(r'```json\s*|\s*```', '', texte.strip()) | |
| action = json.loads(clean) | |
| except (LLMUnavailableError, json.JSONDecodeError) as e: | |
| st.session_state[history_key].append({"role": "assistant", "content": f"[ATTENTION] Assistant indisponible : {e}"}) | |
| st.rerun() | |
| return | |
| tool_name = action.get("tool", "none") | |
| # Filtrage impose cote Python : meme si le LLM a ete manipule (injection de | |
| # prompt) pour demander un outil hors liste blanche, l'appel n'a jamais lieu. | |
| if tool_name in TOOL_FUNCTIONS and tool_name not in allowed_tool_names: | |
| reponse = "Cet outil n'est pas disponible sur cette page." | |
| elif tool_name in TOOL_FUNCTIONS: | |
| calc_args = {k: v for k, v in (action.get("args") or {}).items() if k in _ALLOWED_ARGS} | |
| try: | |
| with st.spinner(f"Calcul en cours ({tool_name})..."): | |
| result = TOOL_FUNCTIONS[tool_name](client, sheet_name, **calc_args) | |
| reponse = f"{action.get('reponse', '').strip()}\n\n```json\n{json.dumps(result, ensure_ascii=False, indent=2)}\n```".strip() | |
| except Exception as e: | |
| reponse = f"[ATTENTION] Erreur lors du calcul ({tool_name}) : {e}" | |
| elif tool_name in actions: | |
| try: | |
| with st.spinner(f"Exécution en cours ({tool_name})..."): | |
| result = actions[tool_name]["fn"](**(action.get("args") or {})) | |
| reponse = f"{action.get('reponse', '').strip()}\n\n[OK] {result.get('message', 'Action exécutée.')}".strip() | |
| except Exception as e: | |
| reponse = f"[ATTENTION] Erreur lors de l'exécution de l'action ({tool_name}) : {e}" | |
| else: | |
| reponse = action.get("reponse") or "Je n'ai pas compris la question." | |
| st.session_state[history_key].append({"role": "assistant", "content": reponse}) | |
| st.rerun() | |