feat(competences): plan supervised replay tests

visual_workflow_builder/backend/catalog_routes_v2_vlm.py

@@ -86,11 +86,13 @@ except ImportError:
 
 try:
     from core.competences.catalog import load_competence_catalog_actions
+    from core.competences.replay import build_competence_replay_payload
     COMPETENCE_CATALOG_AVAILABLE = True
 except ImportError as e:
     print(f"⚠️ Catalogue compétences Léa non disponible: {e}")
     COMPETENCE_CATALOG_AVAILABLE = False
     load_competence_catalog_actions = None
+    build_competence_replay_payload = None
 
 
 # ============================================================================
@@ -1088,6 +1090,119 @@ def _load_lea_competence_actions() -> List[Dict[str, Any]]:
         return []
 
 
+def _extract_competence_id(action_type: str, parameters: Dict[str, Any]) -> str:
+    competence_id = str(parameters.get("competence_id") or "").strip()
+    if competence_id:
+        return competence_id
+    prefix = "lea_competence_"
+    if action_type.startswith(prefix):
+        return action_type[len(prefix):]
+    return ""
+
+
+def _execute_lea_competence_action(
+    data: Dict[str, Any],
+    action_type: str,
+    step_id: str,
+    parameters: Dict[str, Any],
+):
+    """Plan or start a supervised replay from a persisted competence YAML."""
+
+    if not COMPETENCE_CATALOG_AVAILABLE or build_competence_replay_payload is None:
+        return jsonify({
+            "success": False,
+            "error": "Catalogue compétences Léa non disponible",
+        }), 503
+
+    competence_id = _extract_competence_id(action_type, parameters)
+    if not competence_id:
+        return jsonify({
+            "success": False,
+            "error": "Paramètre competence_id requis",
+        }), 400
+
+    supervised = bool(parameters.get("supervised", True))
+    try:
+        payload = build_competence_replay_payload(
+            competence_id,
+            supervised=supervised,
+            machine_id=data.get("machine_id") or data.get("machineId") or parameters.get("machine_id"),
+            session_id=data.get("session_id") or data.get("sessionId") or parameters.get("session_id"),
+        )
+    except KeyError:
+        return jsonify({
+            "success": False,
+            "error": f"Compétence '{competence_id}' introuvable",
+        }), 404
+
+    start_replay = bool(parameters.get("start_replay", False))
+    if not start_replay:
+        return jsonify({
+            "success": True,
+            "result": {
+                "action_id": f"test_competence_{competence_id}_{step_id}",
+                "step_id": step_id,
+                "status": "planned",
+                "output_data": {
+                    "competence_id": competence_id,
+                    "supervised": supervised,
+                    "actions": payload["actions"],
+                    "raw_replay_payload": payload,
+                    "message": "Plan de replay supervisé prêt. Relancer avec start_replay=true pour injecter dans le streaming server.",
+                },
+                "evidence_list": [],
+                "error": None,
+            },
+        })
+
+    try:
+        stream_token = os.environ.get("RPA_API_TOKEN", "")
+        headers = {"Authorization": f"Bearer {stream_token}"} if stream_token else {}
+        response = requests.post(
+            f"{os.environ.get('RPA_STREAMING_SERVER_URL', 'http://localhost:5005')}/api/v1/traces/stream/replay/raw",
+            json=payload,
+            headers=headers,
+            timeout=5,
+        )
+    except Exception as e:
+        return jsonify({
+            "success": False,
+            "error": f"Impossible de contacter le streaming server: {e}",
+            "raw_replay_payload": payload,
+        }), 502
+
+    try:
+        replay_data = response.json()
+    except Exception:
+        replay_data = {"raw": response.text}
+
+    if not response.ok:
+        return jsonify({
+            "success": False,
+            "error": "Le streaming server a refusé le replay compétence",
+            "status_code": response.status_code,
+            "detail": replay_data,
+            "raw_replay_payload": payload,
+        }), response.status_code
+
+    return jsonify({
+        "success": True,
+        "result": {
+            "action_id": f"test_competence_{competence_id}_{step_id}",
+            "step_id": step_id,
+            "status": "started",
+            "output_data": {
+                "competence_id": competence_id,
+                "supervised": supervised,
+                "replay": replay_data,
+                "raw_replay_payload": payload,
+            },
+            "evidence_list": [],
+            "error": None,
+        },
+    })
+
+
 def get_screen_capturer():
     """
     Obtient l'instance du ScreenCapturer (initialisation paresseuse).
@@ -1804,6 +1919,9 @@ def execute_action():
 
         parameters = data.get('parameters', {})
 
+        if action_type == "test_competence" or action_type.startswith("lea_competence_"):
+            return _execute_lea_competence_action(data, action_type, step_id, parameters)
+
         # LOG DEBUG - Voir ce qui arrive du frontend
         print(f"\n{'='*60}")
         print(f"🔥 REQUÊTE EXECUTE REÇUE:")