feat(p1): persist workflows and semantic learning artifacts

core/detection/ollama_client.py

@@ -16,6 +16,48 @@ import io
 logger = logging.getLogger(__name__)
 
 
+def _extract_first_json_object(text: str) -> Optional[Dict[str, Any]]:
+    """Extrait le premier objet JSON racine d'un texte qui peut contenir
+    du contenu parasite après (typique des modèles VLM qui ajoutent une
+    explication post-JSON).
+
+    Retourne None si aucun JSON valide n'est trouvé.
+    """
+    if not text:
+        return None
+    # Trouver la première '{' au niveau racine
+    start = text.find("{")
+    if start < 0:
+        return None
+    depth = 0
+    in_string = False
+    escape = False
+    for i in range(start, len(text)):
+        c = text[i]
+        if escape:
+            escape = False
+            continue
+        if c == "\\" and in_string:
+            escape = True
+            continue
+        if c == '"':
+            in_string = not in_string
+            continue
+        if in_string:
+            continue
+        if c == "{":
+            depth += 1
+        elif c == "}":
+            depth -= 1
+            if depth == 0:
+                candidate = text[start : i + 1]
+                try:
+                    return json.loads(candidate)
+                except json.JSONDecodeError:
+                    return None
+    return None
+
+
 class OllamaClient:
     """
     Client Ollama pour VLM
@@ -219,7 +261,93 @@ class OllamaClient:
                 "success": False,
                 "error": str(e)
             }
-    
+
+    def generate_grounding(
+        self,
+        prompt: str,
+        image_path: Optional[str] = None,
+        image: Optional[Image.Image] = None,
+        extra_images_b64: Optional[List[str]] = None,
+        profile: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """D5-v2 (2026-05-25) : appel grounding VLM centralisé, prefill-aware.
+
+        Utilise le profil dédié `vlm_config.get_grounding_profile()` pour
+        garantir num_ctx pinned (défaut 4096), prefill JSON, think=false,
+        temperature=0, num_predict court. Évite les chemins qui retomberaient
+        sur qwen2.5vl en ctx 8192.
+
+        Le profile peut être surchargé via param explicite (utile tests).
+
+        Reconstitue le JSON complet via prefill : la réponse Ollama est
+        complétée par le préfixe `{"x_pct":` avant parsing, pour que
+        `json.loads()` voit le JSON natif.
+
+        Args:
+            prompt: prompt textuel (typiquement "Find element X")
+            image_path / image / extra_images_b64: cf. generate()
+            profile: override du profile grounding (sinon get_grounding_profile())
+
+        Returns:
+            Dict avec `response` (texte complet incluant prefill), `success`,
+            `error`, `parsed_json` (dict {x_pct, y_pct, confidence, ...} ou
+            None si non parsable), `profile_used` (dict).
+
+        Notes:
+            - Pas de fallback automatique sur fallback_model ici. Le caller
+              décide de retry avec un autre modèle si besoin.
+            - `keep_alive` du profile n'est PAS envoyé en payload (Ollama
+              accepte mais non standard). À gérer côté pull/keep si critique.
+        """
+        if profile is None:
+            from core.detection.vlm_config import get_grounding_profile
+            profile = get_grounding_profile(endpoint=self.endpoint)
+
+        # Préserver le modèle courant, switcher temporairement.
+        original_model = self.model
+        self.model = profile["model"]
+        try:
+            result = self.generate(
+                prompt=prompt,
+                image_path=image_path,
+                image=image,
+                extra_images_b64=extra_images_b64,
+                temperature=profile["temperature"],
+                max_tokens=profile["num_predict"],
+                assistant_prefill=profile["prefill"],
+                num_ctx=profile["num_ctx"],
+                force_json=False,  # prefill suffit, format=json ralentit qwen3.5
+            )
+        finally:
+            self.model = original_model
+
+        # Logging non-bruyant : 1 ligne par appel grounding
+        elapsed_hint = ""  # caller mesure via time.perf_counter si besoin
+        logger.info(
+            "[PERF] vlm.grounding model=%s ctx=%d prefill=%s success=%s",
+            profile["model"], profile["num_ctx"],
+            "yes" if profile["prefill"] else "no",
+            result.get("success", False),
+        )
+
+        # Parse JSON prefill-aware. Le contenu complet inclut déjà le prefill
+        # (reconstitué par generate()) sauf si prefill=None. Si pas de prefill,
+        # tenter parse direct (le modèle peut avoir produit du JSON pur).
+        parsed = None
+        content = (result.get("response") or "").strip()
+        if content:
+            try:
+                # Le JSON peut être suivi de texte parasite (qwen termine
+                # parfois par des explications). Couper à la 1ère accolade
+                # fermante au niveau racine.
+                parsed = _extract_first_json_object(content)
+            except Exception as e:
+                logger.debug("[PERF] vlm.grounding parse failed: %s — content=%r", e, content[:160])
+
+        result["parsed_json"] = parsed
+        result["profile_used"] = dict(profile)
+        return result
+
     def detect_ui_elements(self, image_path: str) -> Dict[str, Any]:
         """
         Détecter les éléments UI dans une image