Lot 30 : motifs de relance personnalisés tenus par la façade

La surcharge retry_patterns (tableau JSON de regex du Go, chacune en
(?mi)) ne garde plus la conversation au Go : la façade la lit au
démarrage de sa conversation, comme le Go la compile une fois par
processus ; illisible ou vide, les motifs embarqués s'appliquent, une
regex illisible est sautée.

Les regex restent celles du Go : chat::stream::go_regex réécrit pour le
crate regex ce qui n'a pas le même sens — classes Perl et limites de mot
ASCII (\w \d \s \b et leurs contraires, dans et hors d'une classe),
\Q…\E (refusé dans une classe, comme le Go), [ && -- ~~ dans une classe,
octal permis, référence arrière refusée.

Parité : parity_retry_test.go compile côté Go une soixantaine de regex
(dont celles qu'il refuse) et note leur première correspondance sur onze
textes (accents, chiffres non ASCII, espaces insécables, crochets) ;
tests/retry.rs rejoue le journal à l'identique et vérifie la lecture de
la surcharge au démarrage.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016tcGfJWefW5kUGoC2wL8cv

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

@@ -869,7 +869,8 @@ pub async fn start_with(
             sessions::GoSessionHooks(store.clone()),
         );
         s.load().await.unwrap();
-        let shared = ChatShared::for_sessions(&s, store, home.join("chatimg"));
+        let mut shared = ChatShared::for_sessions(&s, store.clone(), home.join("chatimg"));
+        shared.patterns = loki_rs::chat::generate::retry_patterns(&store).await;
         Some(ChatService::new(Arc::new(s), Arc::new(shared)))
     } else {
         None

rust/loki-rs/tests/retry.rs

@@ -0,0 +1,68 @@
+//! Lot 30 : les motifs `retry_patterns` d'une surcharge, rejoués sur le
+//! journal tiré du Go (`internal/loki/parity_retry_test.go` →
+//! `tests/parity_retry/patterns.json`) : même compilation, même première
+//! correspondance.
+
+mod common;
+
+use common::fakego;
+use loki_rs::chat::stream::compile_go_regex;
+use serde_json::Value;
+
+#[test]
+fn motifs_comme_le_go() {
+    let fx: Value =
+        serde_json::from_str(include_str!("parity_retry/patterns.json")).expect("journal");
+    let inputs: Vec<&str> = fx["inputs"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .map(|v| v.as_str().unwrap())
+        .collect();
+    for e in fx["patterns"].as_array().unwrap() {
+        let pat = e["pattern"].as_str().unwrap();
+        let re = compile_go_regex(&format!("(?mi){pat}"));
+        assert_eq!(re.is_some(), e["compiles"].as_bool().unwrap(), "{pat}");
+        let Some(re) = re else { continue };
+        for m in e["matches"].as_array().unwrap() {
+            let input = inputs[m["in"].as_u64().unwrap() as usize];
+            let got = re
+                .find(input)
+                .map(|x| (x.as_str().to_string(), x.start() as i64));
+            let want = m["match"]
+                .as_str()
+                .map(|s| (s.to_string(), m["at"].as_i64().unwrap()));
+            assert_eq!(got, want, "{pat} sur {input:?}");
+        }
+    }
+}
+
+/// La surcharge est lue au démarrage de la conversation de la façade ;
+/// absente ou illisible, les motifs embarqués s'appliquent.
+#[tokio::test]
+async fn surcharge_lue_au_demarrage() {
+    for (seed, custom, n) in [
+        (Some(r#"["^oups", "[", "\\bdo_\\w+\\("]"#), true, 2),
+        (Some("pas du json"), false, 0),
+        (None, false, 0),
+    ] {
+        let tmp = tempfile::tempdir().unwrap();
+        let (_f, _go, _stop, chat) = fakego::start_with(
+            tmp.path().to_path_buf(),
+            fakego::Opts {
+                chat: true,
+                seed: seed
+                    .map(|s| vec![("state".into(), "retry_patterns".into(), s.into())])
+                    .unwrap_or_default(),
+                ..Default::default()
+            },
+        )
+        .await;
+        let p = &chat.unwrap().shared.patterns;
+        assert_eq!(p.is_custom(), custom, "{seed:?}");
+        if custom {
+            assert_eq!(p.len(), n);
+            assert!(p.textual_tool_call("OUPS, raté"));
+        }
+    }
+}