feat: live streaming in qa_cli + layered diagnostic + Windows UTF-8 fix

Problème: avec llama3.2:3b sur CPU, chaque inférence prend 60-120s.
Le CLI restait silencieux pendant ce temps → impression de hang.

- tools/jdm_agent.py: stream(agent, q, on_event) consomme agent.stream()
en mode "updates" et émet un dict par message (AIMessage / ToolMessage).
- apps/qa_cli.py: utilise stream() avec --verbose pour afficher chaque
appel d'outil et chaque retour en direct (avec timing).
- apps/diagnose.py (jdm-diag): teste les 5 couches séquentiellement
(client, tools, ollama, inférence nue, 1 round agent) avec timings.
Aide à isoler où ça bloque réellement.
- apps/_console.py: force sys.stdout/stderr en UTF-8 sur Windows
(cp1252 plantait sur ✓ ─ ⏱ et autres unicode). Importé en tête
de chaque entrypoint d'app.
- pyproject: nouveau script jdm-diag.
- README: section "Dépannage" avec tableau symptômes/causes/solutions,
et avertissement explicite sur les temps d'inférence CPU.

Diagnostic live (machine Hani, CPU only):
- couche 1 (HTTP JDM): 0.7s ; cache disque 0.2ms (3500x speedup)
- couche 2 (tools): 0.5s
- couche 3 (Ollama tags): 2.1s
- couche 4 (inférence nue "OUI"): 94.7s — chargement modèle + 1 token
- couche 5 (1 round agent complet): 271s — 2 inférences successives
Tests 30/30 verts.

README.md

@@ -48,12 +48,27 @@ python -m jdm_agent.apps.qa_cli
 
 # Avec Ollama local (modèle compatible tool-calling)
 ollama pull llama3.2:3b
-python -m jdm_agent.apps.qa_cli --provider ollama --model llama3.2:3b
+python -m jdm_agent.apps.qa_cli --provider ollama --model llama3.2:3b --verbose
 
-# Question unique
-python -m jdm_agent.apps.qa_cli -q "synonymes de voiture"
+# Question unique avec streaming des étapes
+python -m jdm_agent.apps.qa_cli --provider ollama --model llama3.2:3b -q "synonymes de voiture" --verbose
 ```
 
+> ⏱️ Sur CPU sans GPU, llama3.2:3b prend **30–120 s par tour** (chargement modèle
+> au 1er appel + chaque round agent ≈ 60–90 s). Utilise `--verbose` pour voir l'agent
+> travailler en direct (chaque appel d'outil et chaque retour s'affiche au fur et à mesure).
+
+### Diagnostic en couches
+
+Si quelque chose semble figé, isole l'étape qui bloque :
+
+```bash
+python -m jdm_agent.apps.diagnose --provider ollama --model llama3.2:3b
+```
+
+Teste séquentiellement : client JDM → outils LangChain → serveur Ollama → inférence
+LLM nue → un round complet d'agent, avec timing à chaque étape.
+
 ### Banc d'évaluation
 
 ```bash
@@ -99,6 +114,17 @@ les synonymes de voiture »* ou *« avec JDM, quels sont les sens du mot avocat
 pytest
 ```
 
+## Dépannage
+
+| Symptôme | Cause probable | Solution |
+|---|---|---|
+| Le CLI semble figé pendant 60-120 s | Inférence Ollama sur CPU (premier chargement modèle + chaque tour LLM) | Utilise `--verbose` pour voir l'agent travailler en direct. Le 1er appel charge le modèle (~10-30 s), les suivants vont plus vite. |
+| `UnicodeEncodeError: 'charmap'` | Console Windows cp1252 | Déjà corrigé (`apps/_console.py` force UTF-8 au démarrage). Si tu vois encore l'erreur, fais `chcp 65001` avant de lancer Python. |
+| `could not connect to a running Ollama instance` | Daemon Ollama pas démarré | Lance `ollama serve` dans un autre terminal (ou redémarre l'app Ollama). |
+| Réponse contient `r_001 \| terme1 \| ...` inventé | Petit modèle qui hallucine les triplets | Passe à un modèle plus capable (`ollama pull qwen2.5:7b` ou `llama3.1:8b`), ou branche une vraie API (Anthropic/OpenAI). |
+| `min_weight: Input should be a valid number` | Bug ancien — déjà corrigé | Mets à jour : `git pull && pip install -e .` |
+| Outputs avec `?` à la place des accents (`syst?me`) | Encodage console non-UTF-8 | `chcp 65001` puis `set PYTHONIOENCODING=utf-8` avant Python |
+
 ## Roadmap
 
 - [x] Phase 0 — Bootstrap

pyproject.toml

@@ -37,6 +37,7 @@ dev = [
 jdm-qa = "jdm_agent.apps.qa_cli:main"
 jdm-eval = "jdm_agent.apps.qa_eval:main"
 jdm-mcp = "jdm_agent.mcp.server:main"
+jdm-diag = "jdm_agent.apps.diagnose:main"
 
 [tool.hatch.build.targets.wheel]
 packages = ["src/jdm_agent"]

src/jdm_agent/apps/_console.py

@@ -0,0 +1,34 @@
+"""Force la sortie console en UTF-8 (Windows cp1252 plante sinon sur ✓ ─ ⏱ …).
+
+À importer en TOUT premier dans chaque entrypoint d'app.
+"""
+from __future__ import annotations
+
+import io
+import sys
+
+
+def setup_console() -> None:
+    for stream_name in ("stdout", "stderr"):
+        stream = getattr(sys, stream_name, None)
+        if stream is None:
+            continue
+        # Python 3.7+: TextIOWrapper.reconfigure(encoding=...)
+        reconf = getattr(stream, "reconfigure", None)
+        if reconf is not None:
+            try:
+                reconf(encoding="utf-8", errors="replace")
+                continue
+            except Exception:
+                pass
+        # Fallback : enveloppe le buffer brut.
+        buffer = getattr(stream, "buffer", None)
+        if buffer is not None:
+            try:
+                setattr(sys, stream_name, io.TextIOWrapper(buffer, encoding="utf-8",
+                                                            errors="replace", line_buffering=True))
+            except Exception:
+                pass
+
+
+setup_console()

src/jdm_agent/apps/diagnose.py

@@ -0,0 +1,191 @@
+"""Diagnostic en couches du système JDM Agent.
+
+Teste séquentiellement :
+  1. JDMClient brut (HTTP + cache)
+  2. Outils LangChain (sans LLM)
+  3. Connectivité Ollama (si choisi)
+  4. Inférence LLM seule (1 prompt court, pas d'outil)
+  5. Agent avec un seul tool call
+
+Affiche le timing de chaque étape pour identifier où ça bloque.
+Usage :
+    python -m jdm_agent.apps.diagnose
+    python -m jdm_agent.apps.diagnose --provider ollama --model llama3.2:3b
+"""
+from __future__ import annotations
+
+from jdm_agent.apps import _console  # noqa: F401 — force stdout UTF-8 (Windows)
+
+import argparse
+import os
+import sys
+import time
+import urllib.request
+import urllib.error
+
+from jdm_agent.client import JDMClient
+from jdm_agent.tools.jdm_tools import set_default_client, get_synonyms
+
+
+GREEN = "\033[92m"
+RED = "\033[91m"
+YELLOW = "\033[93m"
+RESET = "\033[0m"
+
+
+def _step(label: str):
+    print(f"\n── {label} ──", flush=True)
+    return time.time()
+
+
+def _ok(t0: float, extra: str = "") -> None:
+    dt = time.time() - t0
+    print(f"  {GREEN}✓{RESET} {dt:5.2f}s  {extra}", flush=True)
+
+
+def _fail(t0: float, err: Exception) -> None:
+    dt = time.time() - t0
+    print(f"  {RED}✗{RESET} {dt:5.2f}s  {type(err).__name__}: {err}", flush=True)
+
+
+def _warn(msg: str) -> None:
+    print(f"  {YELLOW}!{RESET} {msg}", flush=True)
+
+
+def check_jdm_client() -> bool:
+    t = _step("1. JDMClient HTTP")
+    try:
+        c = JDMClient()
+        n = c.node_by_name("chat")
+        _ok(t, f"node chat id={n.id} w={n.w}")
+        t2 = time.time()
+        n2 = c.node_by_name("chat")
+        dt = time.time() - t2
+        _ok(t2, f"2e appel (cache disque) en {dt*1000:.1f}ms")
+        return True
+    except Exception as e:
+        _fail(t, e)
+        return False
+
+
+def check_tools() -> bool:
+    t = _step("2. Outils LangChain (sans LLM)")
+    try:
+        c = JDMClient()
+        set_default_client(c)
+        syns = get_synonyms.invoke({"term": "voiture", "min_weight": 50, "limit": 3})
+        for s in syns:
+            print(f"     · {s['target']} (w={s['w']})")
+        _ok(t)
+        return True
+    except Exception as e:
+        _fail(t, e)
+        return False
+
+
+def check_ollama(model: str) -> bool:
+    t = _step(f"3. Ollama (modèle {model})")
+    url = os.environ.get("OLLAMA_BASE_URL", "http://localhost:11434") + "/api/tags"
+    try:
+        with urllib.request.urlopen(url, timeout=3) as r:
+            import json
+            data = json.loads(r.read())
+            tags = [m["name"] for m in data.get("models", [])]
+        print(f"     · serveur joignable ; modèles installés : {tags or '(aucun)'}")
+        if not any(m.startswith(model.split(':')[0]) for m in tags):
+            _warn(f"le modèle {model!r} n'est PAS installé. Lancer : ollama pull {model}")
+            return False
+        _ok(t)
+        return True
+    except urllib.error.URLError as e:
+        _fail(t, e)
+        _warn("Ollama ne tourne pas. Démarrer avec : ollama serve")
+        return False
+    except Exception as e:
+        _fail(t, e)
+        return False
+
+
+def check_llm_inference(provider: str, model: str) -> bool:
+    t = _step(f"4. Inférence LLM nue ({provider}:{model}) — peut prendre 10-60s")
+    try:
+        from jdm_agent.tools.llm_factory import get_llm
+        from langchain_core.messages import HumanMessage
+
+        llm = get_llm(provider=provider, model=model)
+        # Force pas d'outils : juste une réponse texte.
+        out = llm.invoke([HumanMessage(content="Réponds en un seul mot : OUI")])
+        _ok(t, f"sortie: {(out.content or '').strip()[:80]!r}")
+        return True
+    except Exception as e:
+        _fail(t, e)
+        return False
+
+
+def check_agent_one_round(provider: str, model: str) -> bool:
+    t = _step(f"5. Agent complet : 1 question simple ({provider}:{model})")
+    try:
+        from jdm_agent.tools.jdm_agent import build_jdm_agent, stream
+
+        client = JDMClient()
+        set_default_client(client)
+        from jdm_agent.tools.llm_factory import get_llm
+        llm = get_llm(provider=provider, model=model)
+        agent = build_jdm_agent(client=client, llm=llm)
+
+        # Stream pour montrer chaque étape.
+        def on_event(ev):
+            dt = time.time() - t
+            kind = ev["kind"]
+            tcs = ev.get("tool_calls") or []
+            if kind == "AIMessage" and tcs:
+                for tc in tcs:
+                    print(f"     [{dt:5.1f}s] → appel {tc['name']}({tc.get('args')})")
+            elif kind == "ToolMessage":
+                content = (ev.get("content") or "")[:80].replace("\n", " ")
+                print(f"     [{dt:5.1f}s] ← outil {ev.get('name')} : {content}…")
+            elif kind == "AIMessage":
+                preview = (ev.get("content") or "").strip().replace("\n", " ")[:80]
+                if preview:
+                    print(f"     [{dt:5.1f}s] ← réponse finale ({len(ev['content'])} chars)")
+
+        out = stream(agent, "Donne-moi 2 synonymes de voiture.", on_event=on_event)
+        print(f"     réponse : {out['answer'][:200]}…")
+        _ok(t)
+        return True
+    except Exception as e:
+        _fail(t, e)
+        return False
+
+
+def main() -> int:
+    p = argparse.ArgumentParser(description="Diagnostic en couches JDM Agent.")
+    p.add_argument("--provider", default=os.environ.get("LLM_PROVIDER", "ollama"))
+    p.add_argument("--model", default=os.environ.get("LLM_MODEL", "llama3.2:3b"))
+    p.add_argument("--skip-llm", action="store_true", help="Saute les étapes 3-5.")
+    args = p.parse_args()
+
+    print(f"{'='*60}\n  JDM Agent — diagnostic\n  provider={args.provider}, model={args.model}\n{'='*60}")
+
+    if not check_jdm_client():
+        return 1
+    if not check_tools():
+        return 1
+    if args.skip_llm:
+        print("\n[--skip-llm] : étapes 3-5 sautées.")
+        return 0
+    if args.provider == "ollama":
+        if not check_ollama(args.model):
+            return 2
+    if not check_llm_inference(args.provider, args.model):
+        return 3
+    if not check_agent_one_round(args.provider, args.model):
+        return 4
+
+    print(f"\n{GREEN}Tout fonctionne.{RESET} Tu peux lancer maintenant :")
+    print(f"  python -m jdm_agent.apps.qa_cli --provider {args.provider} --model {args.model} --verbose")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

src/jdm_agent/apps/qa_cli.py

@@ -11,13 +11,15 @@ Variables d'environnement (alternatives aux flags) :
 """
 from __future__ import annotations
 
+from jdm_agent.apps import _console  # noqa: F401 — force stdout UTF-8 (Windows)
+
 import argparse
 import os
 import sys
 from typing import Optional
 
 from jdm_agent.client import JDMClient
-from jdm_agent.tools.jdm_agent import ask, build_jdm_agent
+from jdm_agent.tools.jdm_agent import ask, build_jdm_agent, stream
 from jdm_agent.tools.llm_factory import get_llm
 
 
@@ -56,6 +58,34 @@ def _print_tool_calls(tool_calls: list[dict]) -> None:
         print(f"  • {tc['name']}({args_str})")
 
 
+def _stream_printer(verbose: bool):
+    """Imprime un événement par étape de l'agent — montre que ça avance."""
+    import time
+    t0 = [time.time()]
+
+    def on_event(ev: dict) -> None:
+        dt = time.time() - t0[0]
+        kind = ev["kind"]
+        if kind == "AIMessage":
+            tcs = ev.get("tool_calls") or []
+            if tcs:
+                for tc in tcs:
+                    args = ", ".join(f"{k}={v!r}" for k, v in (tc.get("args") or {}).items())
+                    print(f"  ⏱ {dt:5.1f}s  →  appel {tc['name']}({args})", flush=True)
+            else:
+                # Réponse finale du modèle.
+                preview = (ev.get("content") or "").strip().replace("\n", " ")[:80]
+                if preview:
+                    print(f"  ⏱ {dt:5.1f}s  ←  réponse du modèle ({len(ev['content'])} chars)", flush=True)
+        elif kind == "ToolMessage":
+            content = ev.get("content") or ""
+            preview = content[:100].replace("\n", " ")
+            print(f"  ⏱ {dt:5.1f}s  ←  outil {ev.get('name')} renvoie {len(content)} chars : {preview}…", flush=True)
+        t0[0] = time.time()
+
+    return on_event if verbose else None
+
+
 def run_repl(provider: Optional[str], model: Optional[str], verbose: bool) -> int:
     print(BANNER)
     print(f"Provider : {provider or os.environ.get('LLM_PROVIDER', 'anthropic')}")
@@ -99,15 +129,15 @@ def run_repl(provider: Optional[str], model: Optional[str], verbose: bool) -> in
             continue
 
         try:
-            out = ask(agent, q)
+            print("(réflexion en cours…)", flush=True)
+            on_event = _stream_printer(show_tools)
+            out = stream(agent, q, on_event=on_event)
         except Exception as e:
             print(f"[erreur] {e}", file=sys.stderr)
             continue
 
         print()
         print(out["answer"])
-        if show_tools:
-            _print_tool_calls(out["tool_calls"])
         print()
 
     client.close()
@@ -126,10 +156,13 @@ def main() -> int:
         client = JDMClient()
         llm = get_llm(provider=args.provider, model=args.model)
         agent = build_jdm_agent(client=client, llm=llm)
-        out = ask(agent, args.question)
-        print(out["answer"])
         if args.verbose:
-            _print_tool_calls(out["tool_calls"])
+            print("(réflexion en cours…)", flush=True)
+            out = stream(agent, args.question, on_event=_stream_printer(True))
+        else:
+            out = ask(agent, args.question)
+        print()
+        print(out["answer"])
         client.close()
         return 0
 

src/jdm_agent/apps/qa_eval.py

@@ -9,6 +9,8 @@ Usage :
 """
 from __future__ import annotations
 
+from jdm_agent.apps import _console  # noqa: F401 — force stdout UTF-8 (Windows)
+
 import argparse
 import time
 from typing import Optional

src/jdm_agent/tools/jdm_agent.py

@@ -73,3 +73,43 @@ def ask(agent, question: str) -> dict:
         for tc in getattr(m, "tool_calls", []) or []:
             tool_calls.append({"name": tc.get("name"), "args": tc.get("args")})
     return {"answer": answer, "messages": msgs, "tool_calls": tool_calls}
+
+
+def stream(agent, question: str, on_event=None):
+    """Stream les étapes intermédiaires de l'agent (LangGraph events).
+
+    Émet un événement par message produit (AIMessage / ToolMessage).
+    Si `on_event` est fourni, il est appelé pour chaque message avec
+    un dict {kind, name, content, tool_calls}.
+
+    Renvoie le dict final {"answer", "messages", "tool_calls"}.
+    """
+    from langchain_core.messages import AIMessage, ToolMessage
+
+    final_msgs = []
+    tool_calls_acc: list[dict] = []
+    for chunk in agent.stream({"messages": [HumanMessage(content=question)]},
+                              stream_mode="updates"):
+        # chunk = dict {node_name: {"messages": [msg, ...]}}
+        for node_name, payload in chunk.items():
+            msgs = (payload or {}).get("messages") or []
+            for m in msgs:
+                final_msgs.append(m)
+                ev = {
+                    "kind": type(m).__name__,
+                    "node": node_name,
+                    "name": getattr(m, "name", None),
+                    "content": getattr(m, "content", ""),
+                    "tool_calls": getattr(m, "tool_calls", None) or [],
+                }
+                for tc in ev["tool_calls"]:
+                    tool_calls_acc.append({"name": tc.get("name"), "args": tc.get("args")})
+                if on_event is not None:
+                    on_event(ev)
+
+    answer = ""
+    for m in reversed(final_msgs):
+        if isinstance(m, AIMessage) and not getattr(m, "tool_calls", None):
+            answer = m.content
+            break
+    return {"answer": answer, "messages": final_msgs, "tool_calls": tool_calls_acc}