Update src/modules/jasmine_agent.py

src/modules/jasmine_agent.py

@@ -1,8 +1,8 @@
 """
-MODULE JASMINE AGENT - V29.5 OPTIMIZED (TOKEN SAVER)
-====================================================
-Optimisation drastique des tokens pour passer dans les limites de Groq/Llama.
-Groupe les propriétés par classe au lieu de lister ligne par ligne.
+MODULE JASMINE AGENT - V30 SILENT EXECUTOR
+==========================================
+Objectif : Forcer le modèle à agir (JSON) sans discuter.
+Modif : Prompt "Headless", Compression Tokens, SPARQL Safe Mode.
 """
 import google.generativeai as genai
 from groq import Groq
@@ -29,11 +29,8 @@ class JasmineAgent:
         self.rdf_store = rdf_store
         self.ontology_rules = ontology_rules
         
-        # ORDRE DE PRIORITÉ : Gemini supporte bcp plus de tokens.
-        # Si Gemini échoue, on passe à Llama 70b (plus robuste que 8b)
-        # Cascade de modèles
+        # PRIORITÉ MODÈLE : Gemini (Context Window large) > Llama
         self.MODEL_CASCADE = [
-
             "gemini-2.0-flash-exp",
             "llama-3.3-70b-versatile",
             "gemini-2.0-flash-lite",
@@ -41,7 +38,7 @@ class JasmineAgent:
         ]
 
     def _generate_dynamic_schema_prompt(self):
-        """Version Compressée : Groupe par Classe pour réduire les tokens"""
+        """Compression du schéma pour économiser les tokens"""
         schema_map = defaultdict(lambda: {"relations": [], "props": []})
 
         for rule in self.ontology_rules:
@@ -50,52 +47,53 @@ class JasmineAgent:
             obj = rule.get('ObjectColOrConcept', 'unknown')
             obj_type = rule.get('ObjectType', 'data_property')
             
-            # Nettoyage
+            # Nettoyage nom prédicat
             pred_clean = predicate if ":" in predicate else f"vortex:{predicate}"
 
             if obj_type == 'relation':
-                schema_map[subject]["relations"].append(f"-> {pred_clean} (vers {obj})")
+                schema_map[subject]["relations"].append(f"-> {pred_clean}")
             else:
                 schema_map[subject]["props"].append(f"{pred_clean}")
 
-        # Construction du texte compact
-        compact_text = []
+        # Texte compact
+        lines = []
         for cls, data in schema_map.items():
-            lines = [f"📦 CLASSE: {cls}"]
-            if data["relations"]:
-                lines.append(f"   🔗 LIENS: {', '.join(data['relations'])}")
-            if data["props"]:
-                lines.append(f"   📝 PROPS: {', '.join(data['props'])}")
-            compact_text.append("\n".join(lines))
+            lines.append(f"📦 {cls}")
+            if data["relations"]: lines.append(f"  🔗 {', '.join(data['relations'])}")
+            if data["props"]: lines.append(f"  📝 {', '.join(data['props'])}")
 
-        return "\n".join(compact_text)
+        return "\n".join(lines)
 
     def build_system_prompt(self):
         dynamic_schema = self._generate_dynamic_schema_prompt()
         
         return f"""
-Tu es JASMINE, Expert SPARQL.
-CONTEXTE RDF (Ontologie Compressée) :
-PREFIX: vortex: <http://vortex.ai/ontology#>
+ROLE: MOTEUR D'EXÉCUTION HEADLESS (JSON ONLY).
+TU N'ES PAS UN CHATBOT. TU NE PARLES PAS. TU EXÉCUTES.
 
+CONTEXTE RDF (ONTOLOGIE) :
+PREFIX: vortex: <http://vortex.ai/ontology#>
 {dynamic_schema}
 
-⚠️ RÈGLES SPARQL :
-1. Les noms de prédicats ci-dessus sont EXACTS.
-2. Pour les Relations (LIENS), utilise `FILTER(CONTAINS(STR(?o), 'Valeur'))`.
-3. Pour les Propriétés (PROPS), utilise `FILTER(?o = 'Valeur')` ou `CONTAINS`.
+⚠️ RÈGLES SPARQL DE SURVIE :
+1. **FILTER SAFE** : Utilise TOUJOURS `FILTER(CONTAINS(STR(?var), 'Valeur'))` au lieu de `?var = 'Valeur'`. Cela évite les erreurs de type (URI vs String).
+2. **NOMS EXACTS** : Utilise uniquement les prédicats listés ci-dessus (ex: `vortex:habite_ville`).
+
+PROTOCOLE DE RÉPONSE :
+1. Si tu dois chercher une info -> Renvoie JSON `execute_sparql`.
+2. Si tu dois trouver une URI -> Renvoie JSON `search_semantic`.
+3. Si tu as fini -> Réponds en texte simple (courtememnt).
 
-🛠️ OUTILS :
-1️⃣ {{ "tool": "search_semantic", "args": {{ "query": "..." }} }}
-2️⃣ {{ "tool": "execute_sparql", "args": {{ "query": "SELECT..." }} }}
+FORMAT ATTENDU (Sortie STRICTE) :
+{{"tool": "execute_sparql", "args": {{"query": "SELECT ?s WHERE {{ ?s vortex:habite_ville ?v . FILTER(CONTAINS(STR(?v), 'Dakar')) }}"}}}}
 
-ACTION UNIQUE. STOP APRÈS JSON.
+INTERDIT D'ÉCRIRE DU TEXTE AVANT OU APRÈS LE JSON.
 """
     
     def _format_messages_for_groq(self, system_prompt, chat_history, user_message):
         msgs = [{"role": "system", "content": system_prompt}]
-        # Réduction de l'historique à 4 messages max pour économiser les tokens
-        for m in chat_history[-4:]:
+        # On garde peu d'historique pour éviter le débordement de tokens
+        for m in chat_history[-3:]:
             role = "assistant" if m["role"] in ["model", "assistant"] else "user"
             content = str(m.get("content", ""))
             if content.strip(): 
@@ -105,7 +103,7 @@ ACTION UNIQUE. STOP APRÈS JSON.
 
     def _format_messages_for_gemini(self, system_prompt, chat_history, user_message):
         msgs = [{"role": "user", "parts": [system_prompt]}]
-        for m in chat_history[-6:]:
+        for m in chat_history[-5:]:
             role = "user" if m["role"] == "user" else "model"
             content = str(m.get("content", ""))
             if content.strip(): 
@@ -121,13 +119,13 @@ ACTION UNIQUE. STOP APRÈS JSON.
             try:
                 response_text = ""
                 if "gemini" in model_name:
-                    if not self.google_key: continue # Skip si pas de clé
+                    if not self.google_key: continue
                     formatted_msgs = self._format_messages_for_gemini(system_prompt, chat_history, user_message)
                     model = genai.GenerativeModel(model_name)
                     res = model.generate_content(formatted_msgs)
                     response_text = res.text
                 else:
-                    if not self.groq_client: continue # Skip si pas de clé
+                    if not self.groq_client: continue
                     formatted_msgs = self._format_messages_for_groq(system_prompt, chat_history, user_message)
                     completion = self.groq_client.chat.completions.create(
                         model=model_name, 
@@ -136,24 +134,23 @@ ACTION UNIQUE. STOP APRÈS JSON.
                     )
                     response_text = completion.choices[0].message.content
 
-                clean_text = re.sub(r"```json", "", response_text, flags=re.IGNORECASE)
-                clean_text = re.sub(r"```", "", clean_text).strip()
+                # Nettoyage agressif pour trouver le JSON
+                clean_text = response_text.strip()
+                match = re.search(r'(\{.*"tool":.*\})', clean_text, re.DOTALL)
                 
                 action = None
-                if "{" in clean_text and "}" in clean_text:
+                if match:
                     try:
-                        json_start = clean_text.find("{")
-                        json_end = clean_text.rfind("}") + 1
-                        json_str = clean_text[json_start:json_end]
+                        json_str = match.group(1)
                         action = json.loads(json_str)
-                        clean_text = clean_text[:json_start] + clean_text[json_end:]
-                        clean_text = clean_text.strip()
+                        return "", action # On retourne une chaîne vide pour le texte, car c'est une action pure
                     except: pass
                 
-                return clean_text, action
+                # Si pas de JSON trouvé, c'est une réponse texte
+                return clean_text, None
 
             except Exception as e:
                 last_error = str(e)
-                continue # Essayer le modèle suivant
+                continue
 
-        return f"⚠️ ERREUR TOUS MODÈLES : {last_error}", None
+        return f"⚠️ ERREUR SYSTEME : {last_error}", None