Conversation tenue par Rust : télémétrie et requêtes en vol comme le Go

Trois choses manquaient au tour tenu par la façade, actives même sans
clé opt-in, et qu'il fallait avant d'en faire le défaut :

- la télémétrie de chaque complétion (perfRecord) : /api/perf/summary et
  l'alerte « cache perdu » posée sur les stats finales d'une étape. La
  boucle Rust la remet au Go (/internal/v1/turn/perf) au même moment que
  la boucle Go, avec ses empreintes de messages ; le Go range, calcule la
  perte et rend nature, jetons perdus et alerte, posés sur la copie finale
  des stats ;
- la sonde du gabarit, lancée dans les mêmes conditions (requête de forme
  normale du moteur local) ;
- le comptage des requêtes en vol : chaque requête au moteur local ouvre
  un ticket (/internal/v1/oai/begin), marqué servi à la réponse 200
  (engineServed, engineMarkMain pour une étape de la discussion), rendu en
  fin de lecture du flux. Le slot de la discussion n'est ainsi ni effacé
  pendant une requête ni pris pour un autre.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

rust/loki-rs/tests/common/fakego.rs

@@ -358,15 +358,48 @@ async fn handle(st: Arc<FakeGo>, req: Request<Incoming>) -> Response<Full<Bytes>
         "/internal/v1/oai/begin" => {
             let body = req.into_body().collect().await.unwrap().to_bytes();
             let v: serde_json::Value = serde_json::from_slice(&body).unwrap();
-            st.oai_log.lock().unwrap().push(format!(
-                "begin read={} side={} post_v1={}",
-                v["read"], v["side"], v["post_v1"]
-            ));
+            if let Some(conv) = v["main_conv"].as_str() {
+                st.oai_log
+                    .lock()
+                    .unwrap()
+                    .push(format!("begin main_conv={conv}"));
+            } else {
+                st.oai_log.lock().unwrap().push(format!(
+                    "begin read={} side={} post_v1={}",
+                    v["read"], v["side"], v["post_v1"]
+                ));
+            }
             if let Some(r) = st.refuse.lock().unwrap().clone() {
                 return resp(200, serde_json::json!({ "refuse": r }).to_string());
             }
             resp(200, r#"{"ticket":7}"#)
         }
+        "/internal/v1/oai/served" => {
+            let body = req.into_body().collect().await.unwrap().to_bytes();
+            let v: serde_json::Value = serde_json::from_slice(&body).unwrap();
+            st.oai_log
+                .lock()
+                .unwrap()
+                .push(format!("served {}", v["ticket"]));
+            resp(204, "")
+        }
+        "/internal/v1/turn/perf" => {
+            let body = req.into_body().collect().await.unwrap().to_bytes();
+            let v: serde_json::Value = serde_json::from_slice(&body).unwrap();
+            st.oai_log.lock().unwrap().push(format!(
+                "perf kind={} conv={} iter={} complete={} prefix={} probe={}",
+                v["kind"].as_str().unwrap_or(""),
+                v["conv"].as_str().unwrap_or(""),
+                v["iter"],
+                v["complete"],
+                v["prefix"].as_array().map_or(0, Vec::len),
+                !v["probe"].is_null()
+            ));
+            resp(
+                200,
+                r#"{"kind":"main","lost":3,"lost_after":"tâche","lost_alert":true}"#,
+            )
+        }
         "/internal/v1/oai/end" => {
             let body = req.into_body().collect().await.unwrap().to_bytes();
             let v: serde_json::Value = serde_json::from_slice(&body).unwrap();