@nosserb/prmt 0.0.0-stage → 2.0.0

package/tui/promethee/app/tour.py

@@ -0,0 +1,539 @@
+"""Un tour avec le modèle : classification de la demande, recherche web, flux de la réponse, relances."""
+from __future__ import annotations
+
+import http.client
+import json
+import shutil
+import urllib.error
+import urllib.request
+from dataclasses import dataclass, field
+
+from textual import work
+from textual.widgets import Markdown
+
+from ..agents import AGENT_HINT, AGENT_MENTION, list_agents
+from ..appels import prune_calls
+from ..config import MAX_STEPS
+from ..consignes import (
+    ANNOUNCE, ASK_CONFIRM, AUDIT_PLAYBOOK, AUDIT_RE, AUDIT_STEPS, CODE_START, CODE_SYSTEM, CONTINUE, EMPTY_REPORT,
+    EXPLAIN_REMINDER, FAILED_CLAIM, MAX_CONTINUES, NO_CONFIRM, NUDGE, REPORT_RE, RETURN_REMINDER, ROUTER_SCHEMA,
+    ROUTER_SYSTEM, RUN_CHECK, SUCCESS_CLAIM, TOOL_REMINDER, TOOL_TEXT, unverified_values, verify_nudge,
+    writes_commands,
+)
+from ..memoire import read_memory
+from ..ollama import OLLAMA, api, http_error_text
+from ..plan import AUDIT_TASKS, MEMORY_HINT, PLAN_FIX, PLAN_REMINDER, missing_cmdlets
+from ..recherche import (
+    OUTIL, SEARCH_ROUTER_SCHEMA, SEARCH_ROUTER_SYSTEM, Classement, chercher, dernier_echange, plan_from,
+    search_result_text, search_router_input,
+)
+from ..theme import CODE_COLOR, DIM, YELLOW
+from ..widgets import AssistantMessage, LOCAL_KEYS, ToolState
+
+
+@dataclass
+class EtatTour:
+    """Ce qu'un tour retient d'une étape à l'autre."""
+    msgs: list[dict]
+    model: str                      # modèle qui répond : Prométhée, ou l'IA de code
+    use_tools: bool
+    mode: str = ""                  # « action », « explication », « plan », ou "" (modèle sans outils)
+    reminder: str = ""              # rappel ajouté au dernier message de l'utilisateur, dans la requête seulement
+    audit: bool = False
+    code_turn: bool = False
+    st: ToolState = field(default_factory=ToolState)
+    final: dict | None = None       # dernier message de fin d'Ollama (compte des jetons, durée)
+    error: str | None = None
+    denied: bool = False            # l'utilisateur a refusé une action, ou la politique en a refusé deux
+    produced: bool = False          # quelque chose est entré dans l'historique
+    executed: bool = False          # le modèle a déjà appelé un outil pendant cette réponse
+    nudged: bool = False            # relancé pour avoir écrit des commandes au lieu de les exécuter
+    verifies: int = 0               # relances « vérifie ton code »
+    honest: bool = False            # relancé pour un succès annoncé après un échec
+    run_checked: bool = False       # relancé pour un programme compilé mais jamais lancé
+    empty_asked: bool = False       # relancé pour une réponse vide
+    plan_checked: bool = False      # les cmdlets du plan ont été vérifiées
+    continues: int = 0              # relances « continue »
+    pending: dict | None = None     # relance en attente (voir _next_nudge)
+    search: dict | None = None      # recherche web décidée par son classement : {query, place} (voir _search_turn)
+
+
+class Tour:
+    """Partie de PrometheeApp : un tour avec le modèle : classification de la demande, recherche web, flux de la réponse,
+    relances."""
+
+    # ------------------------------------------------------------------ boucle d'agent (thread)
+    @work(thread=True, exclusive=True, group="generate")
+    def run_agent(self, history: list[dict], model: str, plan: bool = False) -> None:
+        """Un tour complet : préparer, enchaîner les étapes avec le modèle, contrôler la réponse, rendre la main."""
+        msgs = list(history)
+        if not self._model_ready(msgs, model):
+            return
+        # Mode plan : le modèle ne reçoit aucun outil, il ne peut donc rien exécuter
+        use_tools = self.supports_tools and not plan
+        last_user = next((m.get("intent") or m.get("display") or m["content"] for m in reversed(msgs)
+                          if m["role"] == "user"), "")
+        # « @agent-nom tâche » : la tâche part directement à l'agent, sans passer par le modèle principal
+        mention = AGENT_MENTION.search(last_user) if use_tools else None
+        if mention:
+            self._direct_agent(msgs, mention.group(1))
+            return
+        # Recherche web : son classement passe d'abord, puis l'interpréteur s'il n'y a pas de recherche. L'un après
+        # l'autre, comme pendant la mesure : lancés ensemble, Ollama les calcule en lot et le classement change (65/68 au
+        # lieu de 66/68, lieux moins précis) pour presque rien de gagné.
+        web = self._start_search_plan(msgs, model, plan)
+        found = None
+        if web is not None:
+            self.call_from_thread(self._spinner, True, "check", "Interprétation de la demande")
+            found = web.attendre()
+        if found is not None:
+            self._search_turn(EtatTour(msgs=msgs, model=model, use_tools=False, mode="recherche", search=found))
+            return
+        if self.cancel_event.is_set():
+            # Esc pendant ce classement : le tour s'arrête là, l'interpréteur n'est pas interrogé
+            self.call_from_thread(self.finish_agent, msgs, None, None, True, False, False)
+            return
+        t = self._prepare_turn(msgs, model, plan, use_tools, last_user)
+        for _ in range(MAX_STEPS):
+            if self.cancel_event.is_set() or not self._step(t):
+                break
+        else:
+            self.call_from_thread(self.add_notice, f"Arrêt après {MAX_STEPS} étapes. Dis à Prométhée s'il doit continuer.", YELLOW)
+        self._final_checks(t, len(history))
+        self.call_from_thread(self.finish_agent, t.msgs, t.final, t.error, self.cancel_event.is_set(), t.denied, t.produced)
+
+    def _model_ready(self, msgs: list[dict], model: str) -> bool:
+        """Ollama ne répondait pas au démarrage : on réessaie maintenant, plutôt que de répondre sans outils."""
+        if self.num_ctx is not None or model != self.model:
+            return True
+        self.call_from_thread(self._spinner, True, "check", "Connexion à Ollama")
+        state, problem = self.read_model(model)
+        self.call_from_thread(self._set_model_state, model, state)
+        if problem:
+            self.call_from_thread(self.finish_agent, msgs, None, problem, False, False, False)
+        return not problem
+
+    def _prepare_turn(self, msgs: list[dict], model: str, plan: bool, use_tools: bool, last_user: str) -> EtatTour:
+        """1) Interpréteur : action (exécuter) ou explication (répondre directement) ? programmation ?
+        Choisit le rappel ajouté à la demande et le modèle qui répond (Prométhée, ou l'IA de code)."""
+        forced = next((m.get("mode") for m in reversed(msgs) if m["role"] == "user"), None)
+        mode, reminder, audit, code_turn = "", "", False, False
+        if plan:
+            mode, reminder = "plan", PLAN_REMINDER + (AUDIT_PLAYBOOK if AUDIT_RE.search(last_user) else "")
+        elif use_tools:
+            self.call_from_thread(self._spinner, True, "check", "Interprétation de la demande")
+            self._is_code = False
+            # Interpréteur lancé sur le modèle déjà en mémoire : pas de rechargement juste pour classer
+            judge = self._loaded_model if self._loaded_model in (model, self.code_model) else model
+            mode = forced or self._classify(msgs, judge)
+            if not forced and judge != model and not self._is_code:
+                # L'IA de code (encore chargée) dit « pas du code » : Prométhée va répondre, il doit donc être chargé de
+                # toute façon ; c'est lui qui tranche (qwen3.5 classait « merci ! » en « action » 2 fois sur 3).
+                mode = self._classify(msgs, model)
+            if self._is_code and self.code_auto and self.code_model != model:
+                caps = self.model_caps(self.code_model)
+                if caps is not None and "tools" in caps:
+                    code_turn = True
+                elif not self._code_warned:
+                    self._code_warned = True
+                    self.call_from_thread(self.add_notice, f"IA de code « {self.code_model} » indisponible "
+                                          f"({'non installée' if caps is None else 'sans outils'}) : Prométhée répond. "
+                                          "Change-la avec /code <modèle>.", YELLOW)
+            if mode == "explication":
+                reminder = EXPLAIN_REMINDER
+            else:
+                audit = bool(AUDIT_RE.search(last_user))
+                memory_hint = MEMORY_HINT if read_memory(self.cwd) else ""
+                agent_hint = AGENT_HINT if list_agents(self.cwd) else ""
+                reminder = TOOL_REMINDER[:-1] + agent_hint + memory_hint + ")" + (AUDIT_PLAYBOOK if audit else "")
+                if audit:
+                    self.call_from_thread(self.start_tasks, "audit",
+                                          [{"title": t, "pattern": p} for t, p in AUDIT_TASKS])
+        if code_turn:
+            model = self.code_model
+            self.call_from_thread(self.add_notice, f"⇄ IA de code : {model} prend la main pour cette demande "
+                                  "(Prométhée reprend ensuite).", CODE_COLOR)
+        elif self._last_code and mode != "plan":
+            self.call_from_thread(self.add_notice, "⇄ Retour à Prométhée.", DIM)
+            if mode == "explication":
+                reminder = RETURN_REMINDER
+        self._last_code = code_turn
+        self._turn_model = model
+        self.call_from_thread(self.update_status)
+        return EtatTour(msgs=msgs, model=model, use_tools=use_tools, mode=mode, reminder=reminder, audit=audit, code_turn=code_turn)
+
+    def _step(self, t: EtatTour) -> bool:
+        """Une étape du tour : interroger le modèle, régler la relance en attente, en décider une nouvelle au besoin,
+        sinon garder sa réponse et exécuter ses outils. Renvoie False quand le tour est fini."""
+        bubble, text, calls = self._ask_model(t)
+        # IA de code relancée (« vérifie ») qui répond encore sans rien lancer : on refait les contrôles de relance
+        had_pending = t.pending is not None
+        recheck = bool(t.code_turn and t.pending and t.pending["keep"] and not calls)
+        text, over = self._settle_pending(t, bubble, text, calls)
+        if over:
+            return False
+        nudge = self._next_nudge(t, bubble, text, calls, had_pending, recheck)
+        if nudge is not None:
+            t.pending = nudge
+            return True
+        if not text.strip():
+            self.call_from_thread(bubble.remove)
+        if calls:
+            calls = prune_calls(calls, self.cwd)   # délégation ou lectures lancées à l'aveugle
+        if text or calls:
+            t.produced = True
+            # Le template du modèle n'affiche QUE le texte OU l'appel d'outil d'un message.
+            # Si on gardait la phrase d'intro (« vous pouvez utiliser la commande… »), le modèle
+            # croirait avoir seulement expliqué la commande et arrêterait d'utiliser l'outil.
+            entry: dict = {"role": "assistant", "content": "" if calls else text}
+            if calls:
+                entry["tool_calls"] = calls
+            t.msgs.append(entry)
+        if t.error or self.cancel_event.is_set() or not calls:
+            return False
+        t.executed = True
+        t.denied = self._run_tool_calls(calls, t.msgs, t.st)
+        return not (t.denied or self.cancel_event.is_set())
+
+    def _ask_model(self, t: EtatTour) -> tuple[AssistantMessage, str, list[dict]]:
+        """Envoie la conversation au modèle et diffuse sa réponse. Le rappel et la relance en attente ne sont ajoutés
+        qu'à la requête, jamais à l'historique."""
+        self.call_from_thread(self._spinner, True, "model")
+        bubble = self.call_from_thread(self._new_bubble)
+        system = self.system_message()
+        if t.code_turn and system:
+            system = {"role": "system", "content": system["content"] + CODE_SYSTEM.format(model=t.model)}
+        request = [{k: v for k, v in m.items() if k not in LOCAL_KEYS} for m in t.msgs]
+        if t.reminder:
+            # Rappel (+ méthode d'audit) sur le dernier message de l'utilisateur, à chaque étape
+            idx = max((i for i, m in enumerate(request) if m["role"] == "user"), default=None)
+            if idx is not None:
+                request[idx]["content"] += t.reminder
+        if t.pending:
+            if not t.pending["keep"]:
+                request.append({"role": "assistant", "content": t.pending["text"]})
+            request.append({"role": "user", "content": t.pending["nudge"]})
+        text, calls, turn_final, t.error = self._stream_turn(bubble, ([system] if system else []) + request, t.model, t.use_tools)
+        t.final = turn_final or t.final
+        return bubble, text, calls
+
+    def _settle_pending(self, t: EtatTour, bubble: AssistantMessage, text: str, calls: list[dict]) -> tuple[str, bool]:
+        """Le modèle vient de répondre à une relance : que garde-t-on, à l'écran et dans l'historique ?
+        Renvoie (texte retenu, tour terminé)."""
+        first, t.pending = t.pending, None
+        if first is None:
+            return text, False
+        if first.get("replace"):
+            # Plan corrigé : il remplace le premier à l'écran et dans l'historique (sinon on garde le premier)
+            if text.strip() and not t.error and not self.cancel_event.is_set():
+                self.call_from_thread(first["bubble"].remove)
+                self.call_from_thread(self.add_notice, f"Plan corrigé automatiquement : {first['names']} n'existe pas sur ce PC.")
+                still = missing_cmdlets(text, self.cwd)
+                if still:
+                    self.call_from_thread(self.add_notice, "À vérifier : " + ", ".join(f"`{n}`" for n in still)
+                                          + " n'existe pas non plus sur ce PC.", YELLOW)
+                return text, False
+            self.call_from_thread(bubble.remove)
+            return first["text"], False
+        if calls:
+            if not first["keep"]:
+                # 2) Relance réussie : la réponse écrite disparaît, place à l'exécution
+                self.call_from_thread(first["bubble"].remove)
+                self.call_from_thread(self.add_notice, "Commandes écrites au lieu d'être exécutées : relancé automatiquement.")
+            return text, False
+        if first["keep"]:
+            return text, False   # continuation sans appel d'outil : ce texte est sans doute le rapport final, on le garde
+        # Relance sans effet : on garde la première réponse… sauf si elle contient de faux appels d'outils
+        # (« executer_commande("…") » suivi de « [La sortie de …] ») et pas la seconde
+        fake = TOOL_TEXT.search(first["text"])
+        if fake and text.strip() and not t.error and not TOOL_TEXT.search(text):
+            self.call_from_thread(first["bubble"].remove)
+            kept = text
+        else:
+            self.call_from_thread(bubble.remove)
+            kept = first["text"]
+        t.msgs.append({"role": "assistant", "content": kept})
+        if TOOL_TEXT.search(kept):
+            self.call_from_thread(self.add_notice, "Prométhée a écrit ses appels d'outils au lieu de les "
+                                  "lancer : rien n'a été exécuté. Relance ta demande ou reformule-la.", YELLOW)
+        t.produced = True
+        return kept, True
+
+    def _next_nudge(self, t: EtatTour, bubble: AssistantMessage, text: str, calls: list[dict],
+                    had_pending: bool, recheck: bool) -> dict | None:
+        """Faut-il relancer le modèle au lieu d'accepter sa réponse ? Renvoie la relance, ou None.
+        Une relance : {"bubble", "text", "nudge", "keep"} ; keep = le texte reste affiché et dans l'historique.
+        Chaque cas vient d'un comportement observé sur le modèle ; leur ordre compte."""
+        idle = not calls and not t.error and not self.cancel_event.is_set()   # il a répondu sans appeler d'outil
+        st = t.st
+
+        def kept(nudge: str) -> dict:
+            """Relance qui garde la réponse : elle rejoint l'historique, la consigne s'y ajoute pour le tour suivant."""
+            t.produced = True
+            t.msgs.append({"role": "assistant", "content": text})
+            return {"bubble": bubble, "text": text, "nudge": nudge, "keep": True}
+
+        if t.code_turn and t.executed and idle and not text.strip() and not t.empty_asked:
+            # IA de code qui s'arrête sur une réponse vide (vu après un compactage) : on lui demande son rapport
+            t.empty_asked = True
+            self.call_from_thread(bubble.remove)
+            return {"bubble": bubble, "text": "", "nudge": EMPTY_REPORT, "keep": True}
+        if (recheck or not had_pending) and t.mode == "action" and idle and text.strip():
+            if not t.executed and not t.nudged and writes_commands(text) and not t.code_turn:
+                # Demande d'action mais le modèle a écrit les commandes : on le relance une fois
+                t.nudged = True
+                return {"bubble": bubble, "text": text, "nudge": NUDGE, "keep": False}
+            if t.code_turn and st.unverified and t.verifies < 2:
+                # IA de code : code modifié puis « c'est fait » sans rien relancer → vérifier d'abord
+                t.verifies += 1
+                return kept(verify_nudge(st.unverified, self.cwd))
+            if t.code_turn and st.last_fail and SUCCESS_CLAIM.search(text) and not t.honest:
+                t.honest = True
+                return kept(FAILED_CLAIM.format(cmd=st.last_fail[0], code=st.last_fail[1]))
+            if t.code_turn and st.compiled_only and not t.run_checked:
+                # Compilé mais jamais lancé : une fois, on lui demande de l'essayer sur un exemple
+                t.run_checked = True
+                return kept(RUN_CHECK)
+            if (t.code_turn and not t.executed and t.continues < 2 and len(text) < 800 and "```" not in text
+                    and (ANNOUNCE.search(text) or CODE_START.search(text))):
+                # IA de code qui annonce ce qu'elle va faire mais n'a encore rien lancé : on la relance
+                t.continues += 1
+                return kept(CONTINUE)
+            n_ran = len(st.ran) // 2
+            if t.executed and t.continues < MAX_CONTINUES and (
+                    ANNOUNCE.search(text) or (t.audit and n_ran < AUDIT_STEPS and not REPORT_RE.search(text))
+                    or (self.plan_steps_left() > 0 and not REPORT_RE.search(text) and "bilan" not in text.lower())):
+                # Il annonce l'étape suivante (« Passons au scan… »), ou un audit / un plan accepté s'arrête
+                # avant la fin sans rapport : on le relance
+                t.continues += 1
+                return kept(NO_CONFIRM if ASK_CONFIRM.search(text) else CONTINUE)
+        if (t.mode == "action" and t.executed and idle and t.continues < MAX_CONTINUES and ASK_CONFIRM.search(text)
+                and (self.plan_steps_left() > 0 or (t.audit and len(st.ran) // 2 < AUDIT_STEPS))):
+            # Plan ou audit en cours et il demande la permission par écrit : on le relance
+            t.continues += 1
+            return kept(NO_CONFIRM)
+        if t.mode == "plan" and not t.plan_checked and text.strip() and not t.error and not self.cancel_event.is_set():
+            # Mode plan : les cmdlets citées existent-elles ? Sinon, une seule demande de correction.
+            t.plan_checked = True
+            self.call_from_thread(self._spinner, True, "check", "Vérification du plan")
+            bad = missing_cmdlets(text, self.cwd)
+            if bad:
+                names = ", ".join(f"`{n}`" for n in bad)
+                return {"bubble": bubble, "text": text, "nudge": PLAN_FIX.format(names=names), "keep": False,
+                        "replace": True, "names": names}
+        return None
+
+    def _final_checks(self, t: EtatTour, start: int) -> None:
+        """Après la dernière étape : succès annoncé après un échec, valeurs citées absentes des sorties."""
+        st = t.st
+        last_text = next((m.get("content") or "" for m in reversed(t.msgs) if m["role"] == "assistant"), "")
+        if t.code_turn and st.last_fail and SUCCESS_CLAIM.search(last_text):
+            self.call_from_thread(self.add_notice, f"⚠ L'IA de code dit que ça marche, mais sa dernière commande "
+                                  f"(`{st.last_fail[0]}`) a échoué (code {st.last_fail[1]}) : vérifie avant de t'y fier.",
+                                  f"bold {YELLOW}")
+        if st.ran:
+            # 4) Contrôle de la réponse : valeurs citées absentes de toutes les sorties de commandes ?
+            answer = "\n".join(m.get("content") or "" for m in t.msgs[start:] if m["role"] == "assistant")
+            refs = "\n".join(st.ran + [m.get("content") or "" for m in t.msgs if m["role"] in ("user", "tool")]
+                             + [self.memory_text(), self.summary])
+            missing = unverified_values(answer, refs)
+            if missing:
+                shown = ", ".join(missing[:8]) + (f"… (+{len(missing) - 8})" if len(missing) > 8 else "")
+                self.call_from_thread(self.add_notice, "À vérifier : ces valeurs n'apparaissent dans aucune sortie de "
+                                      f"commande (le modèle a pu les inventer) : {shown}", YELLOW)
+
+    def _classify(self, msgs: list[dict], model: str) -> str:
+        """Interpréteur : « action » ou « explication ». En cas de doute ou d'erreur : action."""
+        last_user, prev, prev_user = "", "", ""
+        for m in reversed(msgs):
+            if m["role"] == "user" and not last_user:
+                last_user = m.get("intent") or m.get("display") or m["content"]
+            elif last_user and m["role"] == "assistant" and m.get("content") and not prev:
+                prev = m["content"]
+            elif prev and m["role"] == "user":
+                # La demande d'avant : sans elle, « et en Rust ? » ou « explique la ligne 3 » n'étaient pas vus comme du code
+                prev_user = m.get("intent") or m.get("display") or m["content"]
+                break
+        content = (f"Demande précédente de l'utilisateur : « {prev_user[:200]} »\n" if prev_user else "") \
+            + (f"Réponse précédente de l'assistant (extrait) : « {prev[-300:]} »\n\n" if prev else "") \
+            + f"Dernière demande : « {last_user} »"
+        payload: dict = {"model": model, "stream": False, "format": ROUTER_SCHEMA,
+                         "options": {"temperature": 0, "num_predict": 30},
+                         "messages": [{"role": "system", "content": ROUTER_SYSTEM}, {"role": "user", "content": content}]}
+        if "thinking" in (self.model_caps(model) or []):
+            payload["think"] = False
+        try:
+            # La réponse est gardée le temps de l'appel : Esc la ferme, la classification s'arrête tout de suite
+            data = json.loads(api("/api/chat", payload, timeout=60, on_open=self._hold_response)["message"]["content"])
+        except Exception:
+            return "action"
+        finally:
+            self._resp = None
+        self._is_code = data.get("code") is True
+        kind = data.get("type")
+        return kind if kind in ("action", "explication") else "action"
+
+    def _hold_response(self, resp) -> None:
+        self._resp = resp
+
+    # ------------------------------------------------------------------ recherche web
+    def _start_search_plan(self, msgs: list[dict], model: str, plan: bool) -> Classement | None:
+        """Lance le classement de la recherche web dans son propre fil, s'il a lieu d'être : recherche active dans les
+        réglages, hors mode plan, et demande qui n'impose pas l'action (/init). Sinon None : le tour se passe comme avant."""
+        forced = next((m.get("mode") for m in reversed(msgs) if m["role"] == "user"), None)
+        if plan or forced or not self.reglage_recherche()["enabled"]:
+            return None
+        snapshot = list(msgs)
+        return Classement(lambda hold: self._search_plan(snapshot, model, hold), self.cancel_event)
+
+    def _search_plan(self, msgs: list[dict], model: str, hold=None) -> dict | None:
+        """Faut-il chercher sur internet avant de répondre ? Un second classement, à part de l'interpréteur ci-dessus qui
+        reste tel quel. Même appel que lui, avec le texte et la mise en forme mesurés dans la console
+        (.equipe/recherche/mesure-routeur.md). Renvoie {query, place}, ou None : pas de recherche (en cas d'erreur aussi)."""
+        last_user, prev, prev_user = dernier_echange(msgs)
+        if not last_user:
+            return None
+        payload: dict = {"model": model, "stream": False, "format": SEARCH_ROUTER_SCHEMA,
+                         "options": {"temperature": 0, "num_predict": 120},
+                         "messages": [{"role": "system", "content": SEARCH_ROUTER_SYSTEM},
+                                      {"role": "user", "content": search_router_input(last_user, prev, prev_user)}]}
+        if "thinking" in (self.model_caps(model) or []):
+            payload["think"] = False
+        try:
+            # La réponse est confiée à hold : Esc la ferme, le classement s'arrête tout de suite
+            data = json.loads(api("/api/chat", payload, timeout=60, on_open=hold)["message"]["content"])
+        except Exception:
+            return None
+        return plan_from(data, last_user)
+
+    def _search_turn(self, t: EtatTour) -> None:
+        """Tour avec recherche web, comme dans la console : la recherche, visible (requête, sources, lieu) et notée au
+        journal, puis la réponse du modèle SANS outil. Un texte venu d'internet ne doit pas pouvoir lui faire proposer une
+        commande dans ce tour. Dans l'historique, la recherche est un appel d'outil « recherche_web » suivi de son
+        résultat. Le détail (sources, lieu) reste dans le message, sous la clé locale « search », pour le réafficher."""
+        plan, msgs, model = t.search, t.msgs, t.model
+        if self._last_code:
+            self.call_from_thread(self.add_notice, "⇄ Retour à Prométhée.", DIM)
+        self._last_code = False
+        self._turn_model = model
+        self.call_from_thread(self.update_status)
+        self.call_from_thread(self._spinner, True, "check", "Recherche web")
+        view = self.call_from_thread(self._new_search_view, plan["query"])
+        search = chercher(self.client_recherche(), plan, self.cancel_event)
+        self.call_from_thread(view.set_result, search)
+        self.noter_recherche(plan, search)
+        args = {"requete": plan["query"], **({"lieu": plan["place"]} if plan["place"] else {})}
+        msgs.append({"role": "assistant", "content": "", "tool_calls": [{"function": {"name": OUTIL, "arguments": args}}],
+                     "search": search})
+        msgs.append({"role": "tool", "tool_name": OUTIL, "content": search_result_text(search)})
+        text, final, error = "", None, None
+        if not self.cancel_event.is_set():
+            self.call_from_thread(self._spinner, True, "model")
+            bubble = self.call_from_thread(self._new_bubble)
+            request = [{k: v for k, v in m.items() if k not in LOCAL_KEYS} for m in msgs]
+            # use_tools=False : aucun outil dans la requête, et un appel d'outil inventé n'est jamais exécuté
+            text, _, final, error = self._stream_turn(bubble, [self.search_system(search)] + request, model, False)
+            if not text.strip():
+                self.call_from_thread(bubble.remove)
+            if text:
+                msgs.append({"role": "assistant", "content": text})
+        self.call_from_thread(self.finish_agent, msgs, final, error, self.cancel_event.is_set(), False, bool(text))
+
+    def model_caps(self, model: str) -> list[str] | None:
+        """Capacités d'un modèle (tools, thinking…), None s'il n'est pas installé. Gardées en cache."""
+        if model not in self._caps:
+            if model == self.model and self.num_ctx is not None:
+                self._caps[model] = (["tools"] if self.supports_tools else []) + \
+                    (["thinking"] if self.supports_thinking else [])
+            else:
+                try:
+                    self._caps[model] = api("/api/show", {"model": model}, timeout=15).get("capabilities") or []
+                except urllib.error.HTTPError:
+                    self._caps[model] = None   # Ollama répond : ce modèle n'est pas installé
+                except Exception:
+                    return None   # Ollama ne répond pas : rien n'est retenu, la prochaine demande réessaiera
+        return self._caps[model]
+
+    def _check_gpu(self, model: str) -> None:
+        """Ollama ne détecte parfois pas la carte graphique au démarrage (après une mise en veille) et tourne alors
+        entièrement sur le processeur : 5 à 10 fois plus lent. On le signale."""
+        if not shutil.which("nvidia-smi"):
+            return
+        try:
+            loaded = api("/api/ps", timeout=10).get("models") or []
+        except Exception:
+            return
+        name = model if ":" in model else f"{model}:latest"
+        entry = next((m for m in loaded if m.get("name") in (model, name)), None)
+        if entry is not None and not entry.get("size_vram"):
+            self.call_from_thread(self.add_notice, "Ollama tourne sur le processeur : ta carte graphique n'a pas été "
+                                  "détectée (souvent après une mise en veille). Les réponses sont 5 à 10 fois plus lentes. "
+                                  "Quitte Ollama (icône près de l'horloge → Quit Ollama), relance-le, puis relance prmt.",
+                                  f"bold {YELLOW}")
+
+    def _stream_turn(self, bubble: AssistantMessage | None, messages: list[dict], model: str, use_tools: bool | list):
+        # bubble = None : rien ne s'affiche (travail d'un agent : seul son rapport compte)
+        # (la recherche du widget Markdown se fait dans le fil de l'interface, comme tout accès aux widgets)
+        stream = self.call_from_thread(lambda: Markdown.get_stream(bubble.markdown)) if bubble is not None else None
+        parts: list[str] = []
+        calls: list[dict] = []
+        final: dict | None = None
+        error: str | None = None
+        payload: dict = {"model": model, "messages": messages, "stream": True}
+        if model != self.model and "thinking" in (self.model_caps(model) or []):
+            payload["think"] = False  # IA de code / modèle d'un agent : réponse directe, bien plus rapide
+        self._loaded_model = model
+        # use_tools : True (outils du modèle principal) ou la liste des outils d'un agent
+        tools = use_tools if isinstance(use_tools, list) else self.request_tools() if use_tools else None
+        if tools:
+            payload["tools"] = tools
+        req = urllib.request.Request(
+            OLLAMA + "/api/chat",
+            data=json.dumps(payload).encode("utf-8"),
+            headers={"Content-Type": "application/json"},
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=600) as resp:
+                self._resp = resp
+                for raw in resp:
+                    if self.cancel_event.is_set():
+                        break
+                    if not raw.strip():
+                        continue
+                    chunk = json.loads(raw)
+                    if "error" in chunk:
+                        error = chunk["error"]
+                        break
+                    msg = chunk.get("message") or {}
+                    if msg.get("thinking"):
+                        self.spin_thinking = True
+                    if msg.get("tool_calls"):
+                        calls.extend(msg["tool_calls"])
+                    piece = msg.get("content") or ""
+                    if piece:
+                        parts.append(piece)
+                        self.spin_tokens += 1
+                        if stream is not None:
+                            self.call_from_thread(stream.write, piece)
+                    if chunk.get("done"):
+                        final = chunk
+                        break
+        except urllib.error.HTTPError as err:
+            error = http_error_text(err)
+        except (OSError, http.client.HTTPException) as err:  # connexion refusée, coupure volontaire (Esc), délai dépassé
+            if not self.cancel_event.is_set():
+                error = f"Impossible de joindre Ollama sur {OLLAMA} ({err}). Lance l'application Ollama puis réessaie."
+        except ValueError as err:  # une ligne de la réponse n'est pas du JSON
+            if not self.cancel_event.is_set():
+                error = f"Réponse illisible d'Ollama ({err}). Réessaie ; si cela continue, relance Ollama."
+        except Exception as err:
+            if not self.cancel_event.is_set():
+                error = f"Erreur inattendue pendant la réponse ({type(err).__name__} : {err})."
+        finally:
+            self._resp = None
+            try:
+                if stream is not None:
+                    self.call_from_thread(stream.stop)
+            except Exception:
+                pass
+        return "".join(parts), calls, final, error