//! Analyse du flux SSE renvoyé par le moteur — port de la partie « protocole »
//! de `runChatLoop` (`llm_client.go`, lecture du flux ~l. 1695–2117), de
//! `streamChunk`, `toolCallLabel`, `argPreview`/`previewArgDone`, `bodyTail`,
//! de la télémétrie tolérante (`perfWire`, `perf_log.go`), de la détection des
//! appels d'outils écrits en texte (`code_retry.go`) et de `repairToolCall`
//! (`code_alias.go`).
//!
//! Machine à états PURE et incrémentale : ni HTTP, ni conversation, ni horloge
//! implicite. Une instance de [`StreamParser`] = une complétion (une tentative
//! de la boucle Go). On lui donne les lignes du corps une à une
//! ([`StreamParser::feed_line`]), puis [`StreamParser::finish`] rend le bilan
//! ([`StreamOutcome`]). Les événements partent dans un rappel qui, comme le
//! `ChatCallback` Go, renvoie `false` pour interrompre le flux.
//!
//! Ce qui reste à la boucle : requête HTTP, statut non-200, lecture et
//! découpage des lignes (`bufio.Scanner`, plafond de 8 Mio : voir
//! [`MAX_LINE_BYTES`]), erreur de lecture (`sc.Err()`), reprises, compactage,
//! télémétrie `perfRecord`, exécution des outils.
//!
//! État global Go devenu paramètre explicite (voir [`StreamConfig`]) :
//! `REASONING` (`reasoning_on`), outils annoncés/coupés/neutralisés
//! (`calls_on`, `tool_choice_none`), preset externe (`external`), politique
//! REASONING_ECHO (`echo_on`, `echo_keeps_past`), compteur de relances
//! « appel textuel » (`pattern_retries`), surcharge `retry_patterns` de la base
//! (`patterns`), instant d'envoi de la requête (`t_req`), `noteEnginePrompt`
//! (`cache_hint`) et la garde d'écriture du mode Code `codeWriteGuard`
//! (`preflight`).

use std::collections::{BTreeMap, HashSet};
use std::sync::{Arc, OnceLock};
use std::time::Instant;

use serde_json::{Map, Value};

use super::types::{StatsEvent, StreamEvent, Tool, ToolCall, ToolUsedEvent};

/// Plafond d'une ligne du flux (`sc.Buffer(…, 8<<20)` en Go). Au-delà, la
/// lecture échoue (`bufio.ErrTooLong`) : c'est à la boucle de le détecter.
pub const MAX_LINE_BYTES: usize = 8 << 20;

/// Balise fermante d'un raisonnement laissé en ligne par le moteur.
pub const THINK_CLOSE: &str = "</think>";

/// Ce qu'un événement de frappe montre du corps : 40 dernières lignes…
pub const BODY_TAIL_LINES: usize = 40;
/// … et 4 Kio au plus.
pub const BODY_TAIL_BYTES: usize = 4096;

/// Relances « appel écrit en texte » consécutives (`maxPatternRetries`).
pub const MAX_PATTERN_RETRIES: i64 = 3;

/// Ouverture de la consigne de relance (`retryCorrectiveLead`, llm_injected.go).
pub const RETRY_CORRECTIVE_LEAD: &str =
    "Your last answer contained a TOOL CALL WRITTEN AS TEXT — it was never executed:\n";

// ───────────────────────── Décodage des chunks ─────────────────────────

/// Le sous-ensemble utile d'un chunk `/v1/chat/completions` (`streamChunk`).
#[derive(Debug, Clone, PartialEq, Default)]
pub struct StreamChunk {
    pub choices: Vec<ChunkChoice>,
    /// `timings` llama.cpp (chunk final).
    pub timings: Option<ChunkTimings>,
    /// `usage` (include_usage), hors `choices`.
    pub usage: Option<ChunkUsage>,
}

#[derive(Debug, Clone, PartialEq, Default)]
pub struct ChunkChoice {
    pub delta: ChunkDelta,
    pub finish_reason: String,
}

#[derive(Debug, Clone, PartialEq, Default)]
pub struct ChunkDelta {
    pub content: String,
    pub reasoning_content: String,
    pub tool_calls: Vec<ToolCall>,
}

#[derive(Debug, Clone, PartialEq, Default)]
pub struct ChunkTimings {
    pub prompt_n: i64,
    pub prompt_ms: f64,
    pub prompt_per_second: f64,
    pub predicted_n: i64,
    pub predicted_ms: f64,
    pub predicted_per_second: f64,
}

#[derive(Debug, Clone, PartialEq, Default)]
pub struct ChunkUsage {
    pub prompt_tokens: i64,
    pub completion_tokens: i64,
    pub total_tokens: i64,
}

/// Erreur de type façon `encoding/json` : le chunk ENTIER est sauté.
struct TypeErr;
type Dec<T> = Result<T, TypeErr>;

/// Repli de casse des clés JSON comme `encoding/json` (EqualFold) : ASCII,
/// plus « ſ » → s et « K » (Kelvin) → k, seuls non-ASCII qui se replient sur
/// une lettre ASCII.
fn fold_char(c: char) -> char {
    match c {
        '\u{17F}' => 's',
        '\u{212A}' => 'k',
        c => c.to_ascii_lowercase(),
    }
}

/// Champ d'un objet : nom exact d'abord, sinon insensible à la casse (Go).
fn field<'a>(obj: &'a Map<String, Value>, name: &str) -> Option<&'a Value> {
    obj.get(name).or_else(|| {
        obj.iter()
            .find(|(k, _)| k.chars().map(fold_char).eq(name.chars().map(fold_char)))
            .map(|(_, v)| v)
    })
}

fn dec_string(v: Option<&Value>) -> Dec<String> {
    match v {
        None | Some(Value::Null) => Ok(String::new()),
        Some(Value::String(s)) => Ok(s.clone()),
        _ => Err(TypeErr),
    }
}

/// `int` Go : un littéral entier seulement (12.0 ou 1e3 font échouer).
fn dec_int(v: Option<&Value>) -> Dec<i64> {
    Ok(dec_opt_int(v)?.unwrap_or(0))
}

fn dec_opt_int(v: Option<&Value>) -> Dec<Option<i64>> {
    match v {
        None | Some(Value::Null) => Ok(None),
        Some(Value::Number(n)) => n.as_i64().map(Some).ok_or(TypeErr),
        _ => Err(TypeErr),
    }
}

fn dec_float(v: Option<&Value>) -> Dec<f64> {
    match v {
        None | Some(Value::Null) => Ok(0.0),
        Some(Value::Number(n)) => n.as_f64().ok_or(TypeErr),
        _ => Err(TypeErr),
    }
}

fn dec_object(v: Option<&Value>) -> Dec<Option<&Map<String, Value>>> {
    match v {
        None | Some(Value::Null) => Ok(None),
        Some(Value::Object(o)) => Ok(Some(o)),
        _ => Err(TypeErr),
    }
}

fn dec_array(v: Option<&Value>) -> Dec<&[Value]> {
    match v {
        None | Some(Value::Null) => Ok(&[]),
        Some(Value::Array(a)) => Ok(a),
        _ => Err(TypeErr),
    }
}

fn dec_tool_call(v: &Value) -> Dec<ToolCall> {
    let mut tc = ToolCall::default();
    let Some(o) = dec_object(Some(v))? else {
        return Ok(tc);
    };
    tc.index = dec_opt_int(field(o, "index"))?;
    tc.id = dec_string(field(o, "id"))?;
    tc.kind = dec_string(field(o, "type"))?;
    if let Some(f) = dec_object(field(o, "function"))? {
        tc.function.name = dec_string(field(f, "name"))?;
        tc.function.arguments = dec_string(field(f, "arguments"))?;
    }
    Ok(tc)
}

fn dec_choice(v: &Value) -> Dec<ChunkChoice> {
    let mut ch = ChunkChoice::default();
    let Some(o) = dec_object(Some(v))? else {
        return Ok(ch);
    };
    if let Some(d) = dec_object(field(o, "delta"))? {
        ch.delta.content = dec_string(field(d, "content"))?;
        ch.delta.reasoning_content = dec_string(field(d, "reasoning_content"))?;
        ch.delta.tool_calls = dec_array(field(d, "tool_calls"))?
            .iter()
            .map(dec_tool_call)
            .collect::<Dec<_>>()?;
    }
    ch.finish_reason = dec_string(field(o, "finish_reason"))?;
    Ok(ch)
}

fn dec_chunk(o: &Map<String, Value>) -> Dec<StreamChunk> {
    let choices = dec_array(field(o, "choices"))?
        .iter()
        .map(dec_choice)
        .collect::<Dec<_>>()?;
    let timings = match dec_object(field(o, "timings"))? {
        None => None,
        Some(t) => Some(ChunkTimings {
            prompt_n: dec_int(field(t, "prompt_n"))?,
            prompt_ms: dec_float(field(t, "prompt_ms"))?,
            prompt_per_second: dec_float(field(t, "prompt_per_second"))?,
            predicted_n: dec_int(field(t, "predicted_n"))?,
            predicted_ms: dec_float(field(t, "predicted_ms"))?,
            predicted_per_second: dec_float(field(t, "predicted_per_second"))?,
        }),
    };
    let usage = match dec_object(field(o, "usage"))? {
        None => None,
        Some(u) => Some(ChunkUsage {
            prompt_tokens: dec_int(field(u, "prompt_tokens"))?,
            completion_tokens: dec_int(field(u, "completion_tokens"))?,
            total_tokens: dec_int(field(u, "total_tokens"))?,
        }),
    };
    Ok(StreamChunk {
        choices,
        timings,
        usage,
    })
}

/// `json.Unmarshal(data, &streamChunk)` : `None` = le chunk est sauté (JSON
/// invalide, octets en trop, ou un champ connu mal typé — y compris dans un
/// `choices[i]` autre que le premier). `null` donne un chunk vide, comme en Go.
pub fn decode_stream_chunk(data: &str) -> Option<StreamChunk> {
    let v: Value = serde_json::from_str(data).ok()?;
    match &v {
        Value::Null => Some(StreamChunk::default()),
        Value::Object(o) => dec_chunk(o).ok(),
        _ => None,
    }
}

// ───────────────────────── Télémétrie tolérante ─────────────────────────

/// Champs de télémétrie du chunk final (`perfWire`), lus sans JAMAIS échouer.
/// `None` = inconnu (absent, mal typé, hors bornes) — ce n'est pas 0.
#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub struct PerfWire {
    pub cache_n: Option<f64>,
    pub draft_n: Option<f64>,
    pub draft_n_accepted: Option<f64>,
    /// `usage.prompt_tokens_details.cached_tokens` (format OpenAI).
    pub cached_tokens: Option<f64>,
}

/// `perfNum.UnmarshalJSON` : un nombre, ou une chaîne qui en contient un ;
/// fini, positif et < 1e12.
fn perf_num(v: Option<&Value>) -> Option<f64> {
    let f = match v? {
        Value::Number(n) => n.as_f64()?,
        Value::String(s) => s.parse::<f64>().ok()?,
        _ => return None,
    };
    (f.is_finite() && (0.0..1e12).contains(&f)).then_some(f)
}

fn perf_ptr(n: Option<f64>) -> Option<i64> {
    n.map(|f| f as i64)
}

/// `decodePerfWire` : seule la PREMIÈRE valeur JSON compte (des octets
/// parasites derrière ne rendent pas tout inconnu) ; une structure de travers
/// laisse sa partie inconnue sans toucher au reste.
pub fn decode_perf_wire(data: &str) -> PerfWire {
    let mut w = PerfWire::default();
    let mut it = serde_json::Deserializer::from_str(data).into_iter::<Value>();
    let Some(Ok(Value::Object(o))) = it.next() else {
        return w;
    };
    if let Some(Value::Object(t)) = field(&o, "timings") {
        w.cache_n = perf_num(field(t, "cache_n"));
        w.draft_n = perf_num(field(t, "draft_n"));
        w.draft_n_accepted = perf_num(field(t, "draft_n_accepted"));
    }
    if let Some(Value::Object(u)) = field(&o, "usage")
        && let Some(Value::Object(d)) = field(u, "prompt_tokens_details")
    {
        w.cached_tokens = perf_num(field(d, "cached_tokens"));
    }
    w
}

/// `applyPerf` : `timings.cache_n` a la priorité ; `cached_tokens` ne comble
/// qu'un cache encore inconnu.
pub fn apply_perf(s: &mut StatsEvent, w: &PerfWire) {
    if let Some(p) = perf_ptr(w.cache_n) {
        s.cache_tokens = Some(p);
    }
    if let Some(p) = perf_ptr(w.draft_n) {
        s.draft_n = Some(p);
    }
    if let Some(p) = perf_ptr(w.draft_n_accepted) {
        s.draft_accepted = Some(p);
    }
    if s.cache_tokens.is_none() {
        s.cache_tokens = perf_ptr(w.cached_tokens);
    }
}

// ───────────────────────── Lecture des arguments en flux ─────────────────────────

/// `writeBodyKey` : l'argument qui porte le texte qu'un outil d'écriture va
/// poser (montré en direct), `None` pour les autres outils.
pub fn write_body_key(tool: &str) -> Option<&'static str> {
    match tool {
        "write" | "mem_add" => Some("content"),
        "edit" | "mem_edit" => Some("new"),
        _ => None,
    }
}

/// Argument montré pendant la frappe d'un appel (table propre à la boucle,
/// distincte de [`tool_call_label`] : pas de see_image, web_grep sur l'URL).
fn typing_label_key(name: &str) -> &'static str {
    match name {
        "mem_search" | "web_search" | "web_images" | "recall_search" => "query",
        "mem_read" | "mem_add" | "mem_edit" | "edit" | "write" | "read" | "git_diff" => "file",
        "recall" | "bash_tail" => "id",
        "web_open" | "web_read" | "web_grep" | "git_clone" => "url",
        "grep" | "glob" => "pattern",
        "ask" => "question",
        "criteria" => "action",
        _ => "command",
    }
}

/// `previewArgDone` : valeur (peut-être incomplète) de `key` dans un JSON
/// d'arguments en cours de flux, et si elle est COMPLÈTE (guillemet fermant
/// reçu). Best-effort : première occurrence de `"key"`, premier ':', premier
/// '"' ; `\r` ignoré, échappement inconnu recopié sans la barre.
pub fn preview_arg_done(args: &str, key: &str) -> (String, bool) {
    let pat = format!("\"{key}\"");
    let Some(i) = args.find(&pat) else {
        return (String::new(), false);
    };
    let rest = &args.as_bytes()[i + pat.len()..];
    let Some(j) = rest.iter().position(|&c| c == b':') else {
        return (String::new(), false);
    };
    let rest = &rest[j + 1..];
    let Some(q) = rest.iter().position(|&c| c == b'"') else {
        return (String::new(), false);
    };
    let rest = &rest[q + 1..];
    let mut b = Vec::new();
    let mut closed = false;
    let mut x = 0;
    while x < rest.len() {
        let c = rest[x];
        if c == b'\\' && x + 1 < rest.len() {
            match rest[x + 1] {
                b'n' => b.push(b'\n'),
                b't' => b.push(b'\t'),
                b'r' => {}
                e => b.push(e),
            }
            x += 2;
            continue;
        }
        if c == b'"' {
            closed = true;
            break;
        }
        b.push(c);
        x += 1;
    }
    (String::from_utf8_lossy(&b).into_owned(), closed)
}

/// `argPreview` : [`preview_arg_done`] au fil du flux, sans relire les
/// arguments à chaque morceau (seuls les octets neufs sont décodés). Seule
/// différence, sur un préfixe : une barre oblique finale reste en attente de
/// son second octet au lieu d'être écrite.
#[derive(Debug, Clone)]
pub struct ArgPreview {
    key: String,
    pat: Vec<u8>,
    /// Octets de `args` déjà consommés.
    pos: usize,
    /// 0 clé, 1 ':', 2 '"' ouvrant, 3 valeur, 4 valeur fermée.
    phase: u8,
    val: Vec<u8>,
    /// '\n' de la valeur décodée.
    lines: usize,
}

impl ArgPreview {
    pub fn new(key: &str) -> Self {
        ArgPreview {
            key: key.to_string(),
            pat: format!("\"{key}\"").into_bytes(),
            pos: 0,
            phase: 0,
            val: Vec::new(),
            lines: 0,
        }
    }

    pub fn key(&self) -> &str {
        &self.key
    }

    /// Consomme la suite de `args`, qui doit prolonger celui des appels
    /// précédents (les arguments d'un appel ne font que grandir).
    pub fn update(&mut self, args: &str) {
        let a = args.as_bytes();
        while self.pos < a.len() && self.phase < 4 {
            match self.phase {
                0 => {
                    // La clé peut être coupée entre deux morceaux : on reprend un peu avant.
                    let s = self.pos.saturating_sub(self.pat.len() - 1);
                    match a[s..]
                        .windows(self.pat.len())
                        .position(|w| w == self.pat.as_slice())
                    {
                        None => {
                            self.pos = a.len();
                            return;
                        }
                        Some(i) => {
                            self.pos = s + i + self.pat.len();
                            self.phase = 1;
                        }
                    }
                }
                1 | 2 => {
                    let sep = if self.phase == 2 { b'"' } else { b':' };
                    match a[self.pos..].iter().position(|&c| c == sep) {
                        None => {
                            self.pos = a.len();
                            return;
                        }
                        Some(j) => {
                            self.pos += j + 1;
                            self.phase += 1;
                        }
                    }
                }
                _ => {
                    let seg = &a[self.pos..];
                    let k = seg
                        .iter()
                        .position(|&c| c == b'\\' || c == b'"')
                        .unwrap_or(seg.len());
                    self.val.extend_from_slice(&seg[..k]);
                    self.lines += seg[..k].iter().filter(|&&c| c == b'\n').count();
                    self.pos += k;
                    if k == seg.len() {
                        return;
                    }
                    if seg[k] == b'"' {
                        self.pos += 1;
                        self.phase = 4;
                        return;
                    }
                    if k + 1 >= seg.len() {
                        return; // échappement coupé : on attend son second octet
                    }
                    match seg[k + 1] {
                        b'n' => {
                            self.val.push(b'\n');
                            self.lines += 1;
                        }
                        b't' => self.val.push(b'\t'),
                        b'r' => {}
                        e => {
                            // '"', '\\', '/', et l'inconnu recopié tel quel
                            self.val.push(e);
                            if e == b'\n' {
                                self.lines += 1;
                            }
                        }
                    }
                    self.pos += 2;
                }
            }
        }
    }

    /// La valeur décodée jusqu'ici (sans copie quand elle est valide).
    pub fn value(&self) -> std::borrow::Cow<'_, str> {
        String::from_utf8_lossy(&self.val)
    }

    /// Guillemet fermant reçu.
    pub fn done(&self) -> bool {
        self.phase == 4
    }

    /// Nombre de '\n' de la valeur.
    pub fn newlines(&self) -> usize {
        self.lines
    }

    /// `body_line_count(value())` sans relire la valeur.
    pub fn line_count(&self) -> usize {
        match self.val.len() {
            0 => 0,
            n if self.val[n - 1] != b'\n' => self.lines + 1,
            1 => 0, // "\n" seul : body_line_count le compte vide
            _ => self.lines,
        }
    }
}

/// `bodyTail` : la fin du corps en cours d'écriture, ses 40 dernières lignes
/// et 4 Kio au plus, coupée en début de ligne (en début de caractère pour une
/// ligne seule plus longue). Le booléen dit que le début a été omis.
pub fn body_tail(s: &str) -> (&str, bool) {
    let start = body_tail_start(s.as_bytes());
    (&s[start..], start > 0)
}

/// Début de [`body_tail`] sur des octets (toujours un début de caractère).
fn body_tail_start(b: &[u8]) -> usize {
    let lo = b.len().saturating_sub(BODY_TAIL_BYTES);
    let (mut start, mut n, mut end) = (None, 0, b.len());
    loop {
        match b[..end].iter().rposition(|&c| c == b'\n') {
            None => {
                if lo == 0 {
                    start = Some(0);
                }
                break;
            }
            Some(i) => {
                if i + 1 < lo {
                    break;
                }
                n += 1;
                start = Some(i + 1);
                if n == BODY_TAIL_LINES {
                    break;
                }
                end = i;
            }
        }
    }
    start.unwrap_or_else(|| {
        let mut st = lo;
        while st < b.len() && (b[st] & 0xC0) == 0x80 {
            st += 1;
        }
        st
    })
}

/// `bodyLineCount` : lignes du corps comme les compte l'UI — un saut de ligne
/// final n'ouvre pas de ligne de plus.
pub fn body_line_count(s: &str) -> usize {
    let s = s.strip_suffix('\n').unwrap_or(s);
    if s.is_empty() {
        return 0;
    }
    s.matches('\n').count() + 1
}

// ───────────────────────── Libellé d'un appel ─────────────────────────

/// Arguments d'un appel décodés comme `json.Unmarshal(…, &map[string]any)` :
/// vide si ce n'est pas un objet JSON.
pub fn call_args(arguments: &str) -> Map<String, Value> {
    serde_json::from_str::<Map<String, Value>>(arguments).unwrap_or_default()
}

fn arg_str(args: &Map<String, Value>, k: &str) -> String {
    match args.get(k) {
        Some(Value::String(s)) => s.clone(),
        _ => String::new(),
    }
}

/// `str` (tracker.go) : chaîne d'un argument, tolérante au type.
fn go_str(v: Option<&Value>) -> String {
    match v {
        None | Some(Value::Null) => String::new(),
        Some(Value::String(s)) => s.clone(),
        Some(Value::Number(n)) => format!("{:.0}", n.as_f64().unwrap_or(0.0)),
        Some(v) => go_fmt_v(v),
    }
}

/// `isMCPTool` : nom routé vers MCP.
pub fn is_mcp_tool(name: &str) -> bool {
    name.starts_with("mcp__")
}

/// `mcpArgLabel` : libellé court des arguments d'un appel MCP.
pub fn mcp_arg_label(args: &Map<String, Value>) -> String {
    if args.is_empty() {
        return String::new();
    }
    for k in ["path", "file", "query", "command", "url", "name"] {
        if let Some(Value::String(v)) = args.get(k)
            && !v.is_empty()
        {
            return v.clone();
        }
    }
    let mut s = String::new();
    go_marshal_object(args, &mut s);
    if s.chars().count() > 120 {
        s = s.chars().take(120).collect::<String>() + "…";
    }
    s
}

/// `toolCallLabel` : le libellé HUMAIN d'un appel (commande, chemin,
/// requête…), annoncé avant l'exécution et argument principal de plusieurs
/// outils. Outil absent de la table : libellé vide.
pub fn tool_call_label(name: &str, args: &Map<String, Value>) -> String {
    match name {
        "mem_search" | "web_search" | "web_images" | "recall_search" => arg_str(args, "query"),
        "mem_read" | "mem_add" | "mem_edit" | "edit" | "write" | "read" | "git_diff"
        | "see_image" => arg_str(args, "file"),
        "recall" | "bash_tail" => arg_str(args, "id"),
        "tracker" => (go_str(args.get("action")) + " " + &go_str(args.get("name")))
            .trim()
            .to_string(),
        "bash" | "bash_bg" => arg_str(args, "command"),
        "grep" | "glob" => arg_str(args, "pattern"),
        "ask" => arg_str(args, "question"),
        "criteria" => arg_str(args, "action"),
        "git_clone" | "web_open" | "web_read" => arg_str(args, "url"),
        "web_grep" => arg_str(args, "pattern") + " @ " + &arg_str(args, "url"),
        _ if is_mcp_tool(name) => mcp_arg_label(args),
        _ => String::new(),
    }
}

// ───────────────────────── Réparation des appels ─────────────────────────

/// `toolNameAliases` : nom halluciné → outil de Loki.
const TOOL_NAME_ALIASES: &[(&str, &str)] = &[
    ("read_file", "read"),
    ("view", "read"),
    ("cat", "read"),
    ("open_file", "read"),
    ("write_file", "write"),
    ("create_file", "write"),
    ("edit_file", "edit"),
    ("str_replace", "edit"),
    ("replace_in_file", "edit"),
    ("str_replace_editor", "edit"),
    ("run_command", "bash"),
    ("shell", "bash"),
    ("run_shell", "bash"),
    ("execute_command", "bash"),
    ("terminal", "bash"),
    ("search", "grep"),
    ("grep_search", "grep"),
    ("search_files", "grep"),
    ("find_files", "glob"),
    ("list_files", "glob"),
    ("file_search", "glob"),
];

const FILE_ALIASES: [(&str, &str); 4] = [
    ("path", "file"),
    ("file_path", "file"),
    ("filename", "file"),
    ("filepath", "file"),
];

/// `toolArgAliases` : par outil, argument halluciné → argument attendu. Ordre
/// fixe (en Go, ordre aléatoire d'une map : voir [`repair_tool_call`]).
fn tool_arg_aliases(tool: &str) -> Vec<(&'static str, &'static str)> {
    match tool {
        "read" => FILE_ALIASES.to_vec(),
        "write" => [
            FILE_ALIASES.as_slice(),
            &[("contents", "content"), ("text", "content")],
        ]
        .concat(),
        "edit" => [
            FILE_ALIASES.as_slice(),
            &[
                ("old_string", "old"),
                ("old_str", "old"),
                ("old_text", "old"),
                ("search", "old"),
                ("new_string", "new"),
                ("new_str", "new"),
                ("new_text", "new"),
                ("replace", "new"),
            ],
        ]
        .concat(),
        "bash" | "bash_bg" => vec![("cmd", "command")],
        "grep" => vec![("query", "pattern"), ("regex", "pattern")],
        "glob" => vec![("query", "pattern")],
        _ => Vec::new(),
    }
}

/// `subagentRoles` (code_subagent.go).
pub const SUBAGENT_ROLES: [&str; 3] = ["explorer", "code-reviewer", "planner"];

/// `repairToolCall` : corrige en place le nom et les arguments d'un appel
/// quand ils visent, sous un autre nom, un outil disponible dans ce tour
/// (read_file → read, path → file, un rôle de sous-agent → subagent{role}).
/// `true` si l'appel a été modifié. Les arguments doivent déjà être du JSON
/// valide ; réécrits comme `json.Marshal` (clés triées, HTML échappé).
///
/// Écart assumé : quand deux alias d'un même argument sont présents
/// (`path` et `file_path`), Go garde celui que l'ordre ALÉATOIRE de sa map
/// visite d'abord ; ici, le premier de la table.
pub fn repair_tool_call(tc: &mut ToolCall, tools: &[Tool]) -> bool {
    let have: HashSet<&str> = tools.iter().map(|t| t.function.name.as_str()).collect();
    let mut name = tc.function.name.clone();
    let mut args = call_args(&tc.function.arguments);
    let mut changed = false;
    if !have.contains(name.as_str()) {
        let lower = name.trim().to_lowercase();
        let alias = TOOL_NAME_ALIASES
            .iter()
            .find(|(from, _)| *from == lower)
            .map(|(_, to)| *to);
        if let Some(t) = alias.filter(|t| have.contains(t)) {
            name = t.to_string();
            changed = true;
        } else if have.contains("subagent") {
            // Un sous-agent appelé comme un outil (« explorer », « code_reviewer »).
            let role = lower.replace('_', "-");
            if let Some(r) = SUBAGENT_ROLES.iter().find(|r| **r == role) {
                if !args.contains_key("role") {
                    args.insert("role".into(), Value::String((*r).into()));
                }
                if !args.contains_key("task") {
                    for k in ["prompt", "query", "question", "description"] {
                        if let Some(Value::String(v)) = args.get(k)
                            && !v.is_empty()
                        {
                            let v = Value::String(v.clone());
                            args.insert("task".into(), v);
                            args.remove(k);
                            break;
                        }
                    }
                }
                name = "subagent".into();
                changed = true;
            }
        }
    }
    for (from, to) in tool_arg_aliases(&name) {
        let Some(v) = args.remove(from) else {
            continue;
        };
        if !args.contains_key(to) {
            args.insert(to.into(), v);
            changed = true;
        }
    }
    if !changed {
        return false;
    }
    let mut out = String::new();
    go_marshal_object(&args, &mut out);
    tc.function.name = name;
    tc.function.arguments = out;
    true
}

/// `json.Valid` : syntaxe seulement (tout type de valeur, blancs autour).
fn json_valid(s: &str) -> bool {
    serde_json::from_str::<serde::de::IgnoredAny>(s).is_ok()
}

/// Appels d'outils d'une complétion, prêts pour l'historique.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct AssembledToolCalls {
    /// Triés par index de flux ; `id` posé (`call_<iter>_<i>` s'il manquait).
    pub calls: Vec<ToolCall>,
    /// Ids des appels dont les arguments étaient du JSON CASSÉ (non vide) :
    /// remplacés par `{}`, à NE PAS exécuter (`badArgs`).
    pub bad_args: HashSet<String>,
}

/// Assemblage des appels accumulés (llm_client.go ~l. 2262–2297) : tri par
/// index, id de secours, arguments invalides neutralisés en `{}` (un vide
/// n'est pas une faute : outil sans paramètre), [`repair_tool_call`] sinon.
/// `iter` : rang de la complétion dans la boucle du tour.
pub fn assemble_tool_calls(
    calls: &BTreeMap<i64, ToolCall>,
    iter: i64,
    tools: &[Tool],
) -> AssembledToolCalls {
    let mut out = AssembledToolCalls::default();
    for (i, tc) in calls.values().enumerate() {
        let mut tc = tc.clone();
        if tc.id.is_empty() {
            tc.id = format!("call_{iter}_{i}");
        }
        if !json_valid(&tc.function.arguments) {
            if !tc.function.arguments.trim().is_empty() {
                out.bad_args.insert(tc.id.clone());
            }
            tc.function.arguments = "{}".into();
        } else {
            repair_tool_call(&mut tc, tools);
        }
        out.calls.push(tc);
    }
    out
}

// ───────────────────────── Appels d'outils écrits en texte ─────────────────────────

/// Un motif d'appel textuel. `find` rend la PREMIÈRE correspondance (la plus
/// à gauche, sémantique RE2/Go) en octets. Les motifs embarqués sont codés à
/// la main ; la surcharge `retry_patterns` (regex quelconques) est fournie par
/// l'appelant.
pub trait RetryPattern: Send + Sync {
    fn find(&self, haystack: &str) -> Option<(usize, usize)>;
}

/// Jeu de motifs (`retryPatterns()`), et s'il s'agit de la surcharge
/// (`retryCustom` : pas de balayage fenêtré, rien ne borne leur portée).
pub struct RetryPatterns {
    pats: Vec<Box<dyn RetryPattern>>,
    custom: bool,
}

impl RetryPatterns {
    /// Les motifs embarqués (`defaultRetryPatterns`), tous en `(?mi)`.
    pub fn builtin() -> Arc<RetryPatterns> {
        static B: OnceLock<Arc<RetryPatterns>> = OnceLock::new();
        B.get_or_init(|| {
            let pats: Vec<Box<dyn RetryPattern>> = vec![
                Box::new(Builtin::Lit("<tool_call>")),
                Box::new(Builtin::Lit("</tool_call>")),
                Box::new(Builtin::Lit("<|tool_call|>")),
                Box::new(Builtin::Lit("```tool_code")),
                Box::new(Builtin::Lit("```tool_call")),
                Box::new(Builtin::DefaultApi),
                Box::new(Builtin::FunctionsCall),
                Box::new(Builtin::JsonName),
                Box::new(Builtin::Lit("[TOOL_REQUEST]")),
                // Format XML de Qwen3-Coder resté en texte.
                Box::new(Builtin::Tag("<function=")),
                Box::new(Builtin::Tag("<parameter=")),
            ];
            Arc::new(RetryPatterns {
                pats,
                custom: false,
            })
        })
        .clone()
    }

    /// La surcharge `retry_patterns` (motifs déjà compilés par l'appelant).
    pub fn custom(pats: Vec<Box<dyn RetryPattern>>) -> RetryPatterns {
        RetryPatterns { pats, custom: true }
    }

    pub fn is_custom(&self) -> bool {
        self.custom
    }

    /// `textualToolCall` : le texte contient un appel d'outil écrit en toutes
    /// lettres au lieu d'être émis par le protocole.
    pub fn textual_tool_call(&self, content: &str) -> bool {
        !self.snippet(content).is_empty()
    }

    /// `textualToolCallFrom` : idem pendant le flux, quand `content[..scanned]`
    /// a DÉJÀ été balayé sans rien trouver — seule la fin est relue (à partir
    /// d'un vrai début de ligne). Surcharge : balayage complet.
    pub fn textual_tool_call_from(&self, content: &str, scanned: usize) -> bool {
        if content.is_empty() {
            return false;
        }
        let start = if self.custom {
            0
        } else {
            retry_scan_start(content, scanned)
        };
        let w = &content[start..];
        self.pats.iter().any(|p| p.find(w).is_some())
    }

    /// `textualToolCallSnippet` : l'extrait fautif (le motif reconnu et ~80
    /// octets de ce qui suit), "" si aucun. Premier motif de la liste qui
    /// correspond, à sa première position.
    pub fn snippet(&self, content: &str) -> String {
        if content.is_empty() {
            return String::new();
        }
        for p in &self.pats {
            if let Some((a, b)) = p.find(content) {
                let mut end = (b + 80).min(content.len());
                while end < content.len() && !content.is_char_boundary(end) {
                    end += 1;
                }
                return content[a..end].trim().to_string();
            }
        }
        String::new()
    }
}

impl RetryPatterns {
    /// `compileRetryPatterns` : la surcharge `retry_patterns` de la base —
    /// un tableau JSON de regex du Go, chacune en `(?mi)`. `None` : absente,
    /// illisible ou vide (les motifs embarqués s'appliquent). Une regex qui
    /// ne se compile pas est sautée, comme le Go le fait.
    pub fn from_override(raw: &str) -> Option<RetryPatterns> {
        if raw.is_empty() {
            return None;
        }
        let over: Vec<String> = serde_json::from_str(raw).ok()?;
        if over.is_empty() {
            return None;
        }
        let pats = over
            .iter()
            .filter_map(|p| compile_go_regex(&format!("(?mi){p}")))
            .map(|r| Box::new(GoRegex(r)) as Box<dyn RetryPattern>)
            .collect();
        Some(RetryPatterns::custom(pats))
    }

    /// Nombre de motifs.
    pub fn len(&self) -> usize {
        self.pats.len()
    }

    pub fn is_empty(&self) -> bool {
        self.pats.is_empty()
    }
}

/// `regexp.Compile` du Go : la regex traduite ([`go_regex`]), octal permis
/// (`\\101`) ; `None` si l'un ou l'autre la refuse.
pub fn compile_go_regex(p: &str) -> Option<regex::Regex> {
    regex::RegexBuilder::new(&go_regex(p)?)
        .octal(true)
        .build()
        .ok()
}

/// Un motif de la surcharge, compilé.
struct GoRegex(regex::Regex);

impl RetryPattern for GoRegex {
    fn find(&self, haystack: &str) -> Option<(usize, usize)> {
        self.0.find(haystack).map(|m| (m.start(), m.end()))
    }
}

/// Une regex du Go (RE2, paquet `regexp`) réécrite pour `regex` : les
/// classes Perl et les limites de mot du Go sont ASCII (`\w`, `\d`, `\s`,
/// `\b`), celles de `regex` Unicode ; `\Q…\E` (texte littéral) n'existe
/// pas en Rust ; dans une classe, `[`, `&&`, `--` et `~~` y ont un sens que
/// le Go ne leur donne pas. `None` : une regex que le Go refuse et que
/// `regex` accepterait (`\\Q` dans une classe).
pub fn go_regex(p: &str) -> Option<String> {
    let cs: Vec<char> = p.chars().collect();
    let mut out = String::with_capacity(p.len() + 16);
    let (mut i, mut class, mut class_start) = (0, false, false);
    while i < cs.len() {
        let c = cs[i];
        if c == '\\' && i + 1 < cs.len() {
            let n = cs[i + 1];
            i += 2;
            if n == 'Q' {
                // Texte littéral jusqu'à \E, ou jusqu'au bout.
                let mut lit = String::new();
                while i < cs.len() && !(cs[i] == '\\' && cs.get(i + 1) == Some(&'E')) {
                    lit.push(cs[i]);
                    i += 1;
                }
                if i < cs.len() {
                    i += 2;
                }
                if class {
                    return None;
                }
                out.push_str(&regex::escape(&lit));
                class_start = false;
                continue;
            }
            // Un chiffre seul est une référence arrière pour le Go, qui la
            // refuse ; avec l'octal permis, `regex` l'accepterait.
            if ('1'..='7').contains(&n) && !cs.get(i).is_some_and(|d| ('0'..='7').contains(d)) {
                return None;
            }
            let rep: &str = match (class, n) {
                (false, 'w') => "[[:word:]]",
                (false, 'W') => "[[:^word:]]",
                (false, 'd') => "[0-9]",
                (false, 'D') => "[^0-9]",
                (false, 's') => r"[\t\n\f\r ]",
                (false, 'S') => r"[^\t\n\f\r ]",
                (false, 'b') => r"(?-u:\b)",
                (false, 'B') => r"(?-u:\B)",
                (true, 'w') => "[:word:]",
                (true, 'W') => "[:^word:]",
                (true, 'd') => "0-9",
                (true, 'D') => "[:^digit:]",
                (true, 's') => r"\t\n\f\r ",
                (true, 'S') => "[:^space:]",
                _ => {
                    out.push('\\');
                    out.push(n);
                    class_start = false;
                    continue;
                }
            };
            out.push_str(rep);
            class_start = false;
            continue;
        }
        if class {
            match c {
                ']' if !class_start => {
                    class = false;
                    out.push(']');
                }
                '[' if cs.get(i + 1) == Some(&':') => {
                    // Classe POSIX : recopiée jusqu'à « :] ».
                    let rest: String = cs[i..].iter().collect();
                    match rest.find(":]") {
                        Some(end) => {
                            out.push_str(&rest[..end + 2]);
                            i += rest[..end + 2].chars().count();
                            class_start = false;
                            continue;
                        }
                        None => out.push_str(r"\["),
                    }
                }
                '[' | '&' | '~' => {
                    out.push('\\');
                    out.push(c);
                }
                '-' if cs.get(i + 1) == Some(&'-') => {
                    out.push_str(r"-\-");
                    i += 1;
                }
                _ => out.push(c),
            }
            class_start = false;
            i += 1;
            continue;
        }
        out.push(c);
        i += 1;
        if c == '[' {
            class = true;
            class_start = true;
            if cs.get(i) == Some(&'^') {
                out.push('^');
                i += 1;
            }
        }
    }
    Some(out)
}

/// Marge relue avant la fin du balayage précédent.
const RETRY_SCAN_MARGIN: usize = 512;
/// Recul au-delà duquel on retombe sur le balayage complet.
const RETRY_SCAN_MAX_BACK: usize = 16 << 10;

/// `retryScanStart` : début de la fenêtre à relire. `scanned − marge`, puis
/// recul tant qu'on est dans une suite que les motifs embarqués peuvent
/// traverser (\w+, \s*, `{"name":`, multioctet), enfin début de ligne. Recul
/// trop long ou ligne sans fin : 0.
pub fn retry_scan_start(content: &str, scanned: usize) -> usize {
    let b = content.as_bytes();
    let scanned = scanned.min(b.len()) as isize;
    let mut p = scanned - RETRY_SCAN_MARGIN as isize;
    if p <= 0 {
        return 0;
    }
    let floor = scanned - RETRY_SCAN_MAX_BACK as isize;
    while p > 0 && retry_run_byte(b[p as usize - 1]) {
        p -= 1;
        if p < floor {
            return 0;
        }
    }
    match b[..p as usize].iter().rposition(|&c| c == b'\n') {
        Some(i) if i as isize + 1 >= floor => i + 1,
        _ => 0,
    }
}

fn retry_run_byte(c: u8) -> bool {
    c >= 0x80
        || c.is_ascii_alphanumeric()
        || matches!(
            c,
            b'_' | b' ' | b'\t' | b'\n' | b'\r' | 0x0c | b'"' | b':' | b'{'
        )
}

/// Motifs embarqués, en sémantique Go `(?mi)` : lettres insensibles à la
/// casse (« s » accepte aussi « ſ », « k » aussi « K » Kelvin, et `\w` les
/// accepte donc aussi), `\b` et `\s` ASCII, `^` en début de texte ou après '\n'.
enum Builtin {
    /// Littéral (premier caractère non alphabétique).
    Lit(&'static str),
    /// `\bdefault_api[.:]\w+`
    DefaultApi,
    /// `\bfunctions\.\w+\s*\(`
    FunctionsCall,
    /// `^\s*\{"name":\s*"(bash|read|grep|glob|edit|write|mem_\w+|web_\w+|git_\w+|criteria|ask)"`
    JsonName,
    /// `<function=\w+>` / `<parameter=\w+>` (préfixe donné).
    Tag(&'static str),
}

/// Littéral ASCII du motif à la position `i` du texte (frontière de
/// caractère), lettres repliées comme `(?i)`. Rend la fin.
fn lit_fold_at(s: &str, mut i: usize, lit: &str) -> Option<usize> {
    let b = s.as_bytes();
    for &p in lit.as_bytes() {
        let c = *b.get(i)?;
        if p.is_ascii_alphabetic() {
            if c.eq_ignore_ascii_case(&p) {
                i += 1;
                continue;
            }
            let lp = p.to_ascii_lowercase();
            if lp == b's' && s[i..].starts_with('\u{17F}') {
                i += 2;
                continue;
            }
            if lp == b'k' && s[i..].starts_with('\u{212A}') {
                i += 3;
                continue;
            }
            return None;
        }
        if c != p {
            return None;
        }
        i += 1;
    }
    Some(i)
}

/// Longueur du caractère de `\w` replié à la position `i`, s'il y en a un.
fn word_fold_len(s: &str, i: usize) -> Option<usize> {
    let c = *s.as_bytes().get(i)?;
    if c.is_ascii_alphanumeric() || c == b'_' {
        return Some(1);
    }
    if s[i..].starts_with('\u{17F}') {
        return Some(2);
    }
    if s[i..].starts_with('\u{212A}') {
        return Some(3);
    }
    None
}

/// `\w+` gourmand depuis `i` : la fin, si au moins un caractère.
fn word_run(s: &str, i: usize) -> Option<usize> {
    let mut j = i;
    while let Some(n) = word_fold_len(s, j) {
        j += n;
    }
    (j > i).then_some(j)
}

fn is_go_space(c: u8) -> bool {
    matches!(c, b'\t' | b'\n' | 0x0c | b'\r' | b' ')
}

/// `\b` avant un caractère de mot : le précédent n'est pas un mot ASCII.
fn word_boundary_before(s: &str, i: usize) -> bool {
    i == 0 || {
        let c = s.as_bytes()[i - 1];
        !(c.is_ascii_alphanumeric() || c == b'_')
    }
}

/// Positions où le premier caractère d'un motif peut commencer. Ce premier
/// caractère est '<', '`', '[', '{', 'd' ou 'f' : aucun n'a de repli non
/// ASCII, un octet ASCII suffit (toujours une frontière de caractère).
fn starts(s: &str, first: u8) -> impl Iterator<Item = usize> + '_ {
    let fl = first.to_ascii_lowercase();
    s.as_bytes()
        .iter()
        .enumerate()
        .filter_map(move |(i, &c)| (c.to_ascii_lowercase() == fl).then_some(i))
}

const JSON_NAME_ALTS: [&str; 8] = [
    "bash", "read", "grep", "glob", "edit", "write", "criteria", "ask",
];
const JSON_NAME_PREFIX_ALTS: [&str; 3] = ["mem_", "web_", "git_"];

impl Builtin {
    fn json_name_end(s: &str, p: usize) -> Option<usize> {
        let b = s.as_bytes();
        let mut i = lit_fold_at(s, p, "{\"name\":")?;
        while i < b.len() && is_go_space(b[i]) {
            i += 1;
        }
        if b.get(i) != Some(&b'"') {
            return None;
        }
        i += 1;
        let quote = |e: usize| (b.get(e) == Some(&b'"')).then_some(e + 1);
        for alt in JSON_NAME_ALTS {
            if let Some(e) = lit_fold_at(s, i, alt).and_then(quote) {
                return Some(e);
            }
        }
        for alt in JSON_NAME_PREFIX_ALTS {
            if let Some(e) = lit_fold_at(s, i, alt)
                .and_then(|e| word_run(s, e))
                .and_then(quote)
            {
                return Some(e);
            }
        }
        None
    }
}

impl RetryPattern for Builtin {
    fn find(&self, s: &str) -> Option<(usize, usize)> {
        let b = s.as_bytes();
        match self {
            Builtin::Lit(lit) => {
                starts(s, lit.as_bytes()[0]).find_map(|i| lit_fold_at(s, i, lit).map(|e| (i, e)))
            }
            Builtin::Tag(prefix) => starts(s, b'<').find_map(|i| {
                let e = lit_fold_at(s, i, prefix)?;
                let e = word_run(s, e)?;
                (b.get(e) == Some(&b'>')).then_some((i, e + 1))
            }),
            Builtin::DefaultApi => starts(s, b'd').find_map(|i| {
                if !word_boundary_before(s, i) {
                    return None;
                }
                let e = lit_fold_at(s, i, "default_api")?;
                if !matches!(b.get(e), Some(b'.' | b':')) {
                    return None;
                }
                word_run(s, e + 1).map(|e| (i, e))
            }),
            Builtin::FunctionsCall => starts(s, b'f').find_map(|i| {
                if !word_boundary_before(s, i) {
                    return None;
                }
                let e = lit_fold_at(s, i, "functions.")?;
                let mut e = word_run(s, e)?;
                while e < b.len() && is_go_space(b[e]) {
                    e += 1;
                }
                (b.get(e) == Some(&b'(')).then_some((i, e + 1))
            }),
            Builtin::JsonName => starts(s, b'{').find_map(|p| {
                let end = Builtin::json_name_end(s, p)?;
                // `^\s*` : le début de ligne le plus à gauche dans les blancs
                // qui précèdent l'accolade.
                let mut ws = p;
                while ws > 0 && is_go_space(b[ws - 1]) {
                    ws -= 1;
                }
                (ws..=p)
                    .find(|&j| j == 0 || b[j - 1] == b'\n')
                    .map(|j| (j, end))
            }),
        }
    }
}

/// `retryCorrective` : le message réinjecté pour relancer le tour, avec
/// l'extrait fautif.
pub fn retry_corrective(snippet: &str) -> String {
    RETRY_CORRECTIVE_LEAD.to_string()
        + snippet
        + "\nTool calls must go through the tool-call protocol, never in the answer text. "
        + "Redo it now: emit the real tool call, or answer directly without pretending to call a tool."
}

// ───────────────────────── Le parseur ─────────────────────────

/// `noteEnginePrompt(prompt_tokens, cached, cachedKnown)` → conseil de cache
/// (`StatsEvent::cache_hint`). Appelé sur le moteur local seulement.
pub type CacheHintFn = Box<dyn FnMut(i64, i64, bool) -> String + Send>;

/// `codeWriteGuard(caps, file, isWrite)` → refus ("" = permis). Sa présence
/// vaut `caps.Code`.
pub type PreflightFn = Box<dyn FnMut(&str, bool) -> String + Send>;

/// Ce que la boucle Go sait de la complétion avant de la lire.
pub struct StreamConfig {
    /// `reasoningActive(REASONING)` : un `<think>` ouvert par le gabarit est
    /// découpé chez nous sur `</think>` (moteur qui le laisse en ligne).
    pub reasoning_on: bool,
    /// Appels exécutables : outils annoncés, ni coupés ni neutralisés.
    pub calls_on: bool,
    /// Relance `tool_choice: "none"` : tout appel (protocole ou texte) est une
    /// fuite qui coupe le flux.
    pub tool_choice_none: bool,
    /// Preset externe (pas de comptage du raisonnement, pas de conseil de cache).
    pub external: bool,
    /// REASONING_ECHO actif pour cette requête (`pol.on`).
    pub echo_on: bool,
    /// Le gabarit garde le raisonnement passé (`pol.keepsPast`).
    pub echo_keeps_past: bool,
    /// Relances « appel textuel » déjà faites dans ce tour (`patternRetries`).
    pub pattern_retries: i64,
    /// Motifs d'appels textuels (embarqués, ou surcharge `retry_patterns`).
    pub patterns: Arc<RetryPatterns>,
    /// Envoi de la requête (`tReq`) : base du TTFT et des stats de secours.
    pub t_req: Instant,
    pub cache_hint: Option<CacheHintFn>,
    pub preflight: Option<PreflightFn>,
}

impl Default for StreamConfig {
    fn default() -> Self {
        StreamConfig {
            reasoning_on: false,
            calls_on: false,
            tool_choice_none: false,
            external: false,
            echo_on: false,
            echo_keeps_past: false,
            pattern_retries: 0,
            patterns: RetryPatterns::builtin(),
            t_req: Instant::now(),
            cache_hint: None,
            preflight: None,
        }
    }
}

/// write/edit refusé en plein flux dès que son chemin est complet.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct PreflightRefusal {
    pub name: String,
    pub id: String,
    pub file: String,
    pub msg: String,
}

enum Preflight {
    Unchecked,
    Checked,
    Refused(PreflightRefusal),
}

/// Bilan d'une complétion lue (en entier ou coupée).
#[derive(Debug, Clone, PartialEq, Default)]
pub struct StreamOutcome {
    /// Tout le `content` reçu (`assistantContent`), `<think>` en ligne compris.
    pub content: String,
    /// Texte de réponse réellement affiché (rendu au modèle après une coupure).
    pub shown: String,
    /// Appels accumulés, par index de flux (voir [`assemble_tool_calls`]).
    pub tool_calls: BTreeMap<i64, ToolCall>,
    pub finish_reason: String,
    /// Stats de la complétion : `echoed` et `ttft_ms` posés, stats de secours
    /// mesurées s'il n'y a pas eu de `timings`.
    pub stats: StatsEvent,
    pub saw_timings: bool,
    pub saw_reasoning_field: bool,
    /// Raisonnement séparé PAR LE SERVEUR, à renvoyer (REASONING_ECHO).
    pub echo_text: String,
    /// Du texte ou un outil est parti vers l'UI.
    pub sent_answer: bool,
    /// Du raisonnement est parti vers l'UI.
    pub sent_reasoning: bool,
    /// Dernier événement d'outil émis (appel en cours d'écriture à l'écran).
    pub typing_tool: Option<ToolUsedEvent>,
    /// Le rappel a demandé l'arrêt.
    pub aborted: bool,
    /// Flux coupé sur un appel d'outil écrit en texte.
    pub pattern_hit: bool,
    /// Sous `tool_choice: "none"`, le modèle a tenté un appel quand même.
    pub none_leak: bool,
    /// write/edit refusé en plein flux.
    pub preflight: Option<PreflightRefusal>,
}

impl StreamOutcome {
    /// Complétion « complète » pour la télémétrie : ni arrêtée, lue jusqu'au
    /// bout (ou finish_reason reçu avant la coupure), avec timings ou usage.
    /// `read_failed` : la lecture du corps a échoué (`sc.Err() != nil`).
    pub fn is_complete(&self, read_failed: bool) -> bool {
        !self.aborted
            && (!read_failed || !self.finish_reason.is_empty())
            && (self.saw_timings || self.stats.prompt_tokens_total > 0)
    }

    /// Une erreur de lecture est sans conséquence : coupure APRÈS le dernier
    /// chunk (finish_reason reçu), ou flux coupé par NOUS (appel textuel,
    /// fuite sous tool_choice none, refus anticipé).
    pub fn read_error_benign(&self) -> bool {
        !self.finish_reason.is_empty()
            || self.pattern_hit
            || self.none_leak
            || self.preflight.is_some()
    }

    /// [`assemble_tool_calls`] sur les appels de cette complétion.
    pub fn assemble_tool_calls(&self, iter: i64, tools: &[Tool]) -> AssembledToolCalls {
        assemble_tool_calls(&self.tool_calls, iter, tools)
    }
}

/// Analyse incrémentale d'UNE complétion streamée.
pub struct StreamParser {
    cfg: StreamConfig,
    tool_calls: BTreeMap<i64, ToolCall>,
    content: String,
    /// Longueur de `content` déjà balayée sans appel textuel.
    retry_scanned: usize,
    finish_reason: String,
    stats: StatsEvent,
    saw_timings: bool,
    t_first: Option<Instant>,
    t_last: Option<Instant>,
    usage_gen: i64,
    gen_chunks: i64,
    last_preview: String,
    last_body_lines: i64,
    label_dec: Option<ArgPreview>,
    body_dec: Option<ArgPreview>,
    sent_answer: bool,
    sent_reasoning: bool,
    shown: String,
    typing_tool: Option<ToolUsedEvent>,
    saw_reasoning_field: bool,
    echo_buf: String,
    think_open: bool,
    think_tail: String,
    aborted: bool,
    pattern_hit: bool,
    none_leak: bool,
    preflight: Preflight,
    stopped: bool,
}

impl StreamParser {
    pub fn new(cfg: StreamConfig) -> Self {
        let think_open = cfg.reasoning_on;
        StreamParser {
            cfg,
            tool_calls: BTreeMap::new(),
            content: String::new(),
            retry_scanned: 0,
            finish_reason: String::new(),
            stats: StatsEvent::default(),
            saw_timings: false,
            t_first: None,
            t_last: None,
            usage_gen: 0,
            gen_chunks: 0,
            last_preview: String::new(),
            last_body_lines: -1,
            label_dec: None,
            body_dec: None,
            sent_answer: false,
            sent_reasoning: false,
            shown: String::new(),
            typing_tool: None,
            saw_reasoning_field: false,
            echo_buf: String::new(),
            think_open,
            think_tail: String::new(),
            aborted: false,
            pattern_hit: false,
            none_leak: false,
            preflight: Preflight::Unchecked,
            stopped: false,
        }
    }

    /// Le flux a été coupé (rappel, appel textuel, fuite, refus anticipé) :
    /// la boucle doit cesser de lire.
    pub fn is_stopped(&self) -> bool {
        self.stopped
    }

    /// `scb` : note ce qui part vers l'UI, puis le rappel.
    fn send<F: FnMut(StreamEvent) -> bool>(&mut self, ev: StreamEvent, emit: &mut F) -> bool {
        match &ev {
            StreamEvent::Content(c) if !c.is_empty() => {
                self.sent_answer = true;
                self.shown.push_str(c);
            }
            StreamEvent::ToolUsed(t) => {
                self.sent_answer = true;
                self.typing_tool = Some(t.clone());
            }
            StreamEvent::Reasoning(r) if !r.is_empty() => self.sent_reasoning = true,
            _ => {}
        }
        emit(ev)
    }

    /// Une ligne du corps (sans son '\n' ; un '\r' final est toléré). `now` :
    /// instant de réception. Rend `false` quand le flux est coupé : la boucle
    /// cesse alors de lire. Les lignes qui ne sont pas `data:`, vides,
    /// `[DONE]` ou indécodables sont ignorées, comme en Go (y compris un
    /// objet `{"error":…}` glissé dans le flux).
    pub fn feed_line<F: FnMut(StreamEvent) -> bool>(
        &mut self,
        line: &str,
        now: Instant,
        emit: &mut F,
    ) -> bool {
        if self.stopped {
            return false;
        }
        let Some(rest) = line.trim().strip_prefix("data:") else {
            return true;
        };
        let data = rest.trim();
        if data.is_empty() || data == "[DONE]" {
            return true;
        }
        let Some(chunk) = decode_stream_chunk(data) else {
            return true;
        };
        if self.on_chunk(chunk, data, now, emit) {
            true
        } else {
            self.stopped = true;
            false
        }
    }

    fn on_chunk<F: FnMut(StreamEvent) -> bool>(
        &mut self,
        chunk: StreamChunk,
        data: &str,
        now: Instant,
        emit: &mut F,
    ) -> bool {
        // Timings ET usage arrivent sur le chunk final, souvent `choices:[]` :
        // traités AVANT le garde de choices.
        let mut pw = PerfWire::default();
        if chunk.timings.is_some() || chunk.usage.is_some() {
            pw = decode_perf_wire(data);
            apply_perf(&mut self.stats, &pw);
        }
        if let Some(t) = &chunk.timings {
            self.saw_timings = true;
            self.stats.prompt_tokens = t.prompt_n;
            self.stats.prompt_per_second = t.prompt_per_second;
            self.stats.prompt_ms = t.prompt_ms;
            self.stats.gen_tokens = t.predicted_n;
            self.stats.gen_per_second = t.predicted_per_second;
            self.stats.gen_ms = t.predicted_ms;
            let s = self.stats.clone();
            self.send(StreamEvent::Stats(s), emit);
        }
        if let Some(u) = &chunk.usage {
            if u.completion_tokens > 0 {
                self.usage_gen = u.completion_tokens;
            }
            if u.prompt_tokens > 0 {
                self.stats.prompt_tokens_total = u.prompt_tokens;
                let mut s = self.stats.clone();
                if !self.cfg.external
                    && let Some(h) = self.cfg.cache_hint.as_mut()
                {
                    let c = pw.cached_tokens;
                    s.cache_hint = h(u.prompt_tokens, perf_ptr(c).unwrap_or(0), c.is_some());
                }
                self.send(StreamEvent::Stats(s), emit);
            }
        }
        let Some(ch) = chunk.choices.into_iter().next() else {
            return true;
        };
        let ChunkChoice {
            delta,
            finish_reason,
        } = ch;
        if !delta.content.is_empty()
            || !delta.reasoning_content.is_empty()
            || !delta.tool_calls.is_empty()
        {
            if self.t_first.is_none() {
                self.t_first = Some(now);
            }
            self.t_last = Some(now);
            self.gen_chunks += 1;
        }
        if !finish_reason.is_empty() {
            self.finish_reason = finish_reason;
        }
        // Relance tool_choice « none » : un appel émis malgré tout n'est pas
        // exécuté, on coupe.
        if self.cfg.tool_choice_none && !delta.tool_calls.is_empty() {
            self.none_leak = true;
            return false;
        }
        if self.cfg.calls_on && !delta.tool_calls.is_empty() {
            return self.on_tool_calls(delta.tool_calls, emit);
        }
        // Outils non annoncés : un appel parsé quand même par le moteur est ignoré.
        if !delta.reasoning_content.is_empty() {
            // Le moteur sépare déjà le raisonnement : plus de découpage chez nous.
            self.saw_reasoning_field = true;
            self.think_open = false;
            if !self.cfg.external {
                self.stats.reasoning_tokens += 1;
            }
            if self.cfg.echo_on {
                self.echo_buf.push_str(&delta.reasoning_content);
            }
            if !self.send(StreamEvent::Reasoning(delta.reasoning_content), emit) {
                self.aborted = true;
                return false;
            }
        }
        if !delta.content.is_empty() {
            return self.on_content(delta.content, emit);
        }
        true
    }

    fn on_tool_calls<F: FnMut(StreamEvent) -> bool>(
        &mut self,
        deltas: Vec<ToolCall>,
        emit: &mut F,
    ) -> bool {
        // Un appel clôt le texte : le reliquat retenu par la garde « </think> »
        // part MAINTENANT, avant l'événement d'outil.
        if self.think_open && !self.think_tail.is_empty() {
            let tail = std::mem::take(&mut self.think_tail);
            if !self.send(StreamEvent::Content(tail), emit) {
                self.aborted = true;
                return false;
            }
        }
        for (i, tc) in deltas.into_iter().enumerate() {
            // Le champ index dit à quel appel appartient ce morceau ; sans lui,
            // la position dans le chunk.
            let idx = tc.index.unwrap_or(i as i64);
            let cur = self.tool_calls.entry(idx).or_insert_with(|| ToolCall {
                kind: "function".into(),
                ..Default::default()
            });
            if !tc.id.is_empty() {
                cur.id = tc.id;
            }
            if !tc.function.name.is_empty() {
                cur.function.name = tc.function.name;
            }
            cur.function.arguments.push_str(&tc.function.arguments);
        }
        // Frappe en direct de l'appel n°0 : son argument parlant, et pour une
        // écriture la FIN de son corps, à la ligne.
        let Some(cur) = self.tool_calls.get(&0) else {
            return true;
        };
        let name = cur.function.name.clone();
        let key = typing_label_key(&name);
        if self.label_dec.as_ref().is_some_and(|d| d.key != key) {
            self.label_dec = None;
        }
        let ld = self.label_dec.get_or_insert_with(|| ArgPreview::new(key));
        ld.update(&cur.function.arguments);
        let p_nonempty = !ld.val.is_empty();
        let p_changed = p_nonempty && ld.val.as_slice() != self.last_preview.as_bytes();
        let mut full_nonempty = false;
        let mut body_nl = 0;
        if let Some(bk) = write_body_key(&name) {
            if self.body_dec.as_ref().is_some_and(|d| d.key != bk) {
                self.body_dec = None;
            }
            let bd = self.body_dec.get_or_insert_with(|| ArgPreview::new(bk));
            bd.update(&cur.function.arguments);
            full_nonempty = !bd.val.is_empty();
            body_nl = bd.lines as i64;
        }
        let grew = full_nonempty && body_nl > self.last_body_lines;
        if p_changed || grew {
            if p_nonempty && let Some(ld) = &self.label_dec {
                self.last_preview = ld.value().into_owned();
            }
            if grew {
                self.last_body_lines = body_nl;
            }
            let mut tu = ToolUsedEvent {
                name: name.clone(),
                label: self.last_preview.clone(),
                typing: true,
                ..Default::default()
            };
            if full_nonempty && let Some(bd) = &self.body_dec {
                // Seule la fin est copiée : relire tout le corps à chaque
                // ligne serait quadratique.
                let start = body_tail_start(&bd.val);
                tu.body = String::from_utf8_lossy(&bd.val[start..]).into_owned();
                tu.body_tail = start > 0;
                tu.body_lines = bd.line_count() as i64;
            }
            if !self.send(StreamEvent::ToolUsed(tu), emit) {
                self.aborted = true;
                return false;
            }
        }
        // Pré-vol du mode Code : dès que le chemin d'un write/edit est
        // complet, la garde décide ; refusé, on coupe la génération.
        if matches!(self.preflight, Preflight::Unchecked)
            && (name == "write" || name == "edit")
            && let Some(guard) = self.cfg.preflight.as_mut()
            && let Some(cur) = self.tool_calls.get(&0)
        {
            let (file, done) = preview_arg_done(&cur.function.arguments, "file");
            if done && !file.trim().is_empty() {
                let msg = guard(&file, name == "write");
                if !msg.is_empty() {
                    self.preflight = Preflight::Refused(PreflightRefusal {
                        name,
                        id: cur.id.clone(),
                        file,
                        msg,
                    });
                    return false;
                }
                self.preflight = Preflight::Checked;
            }
        }
        true
    }

    fn on_content<F: FnMut(StreamEvent) -> bool>(&mut self, c: String, emit: &mut F) -> bool {
        self.content.push_str(&c);
        if !self.think_open || self.saw_reasoning_field {
            let trigger = c.contains(['<', '`', '{', '[', '_', '.']);
            if !self.send(StreamEvent::Content(c), emit) {
                self.aborted = true;
                return false;
            }
            // Appel d'outil écrit en texte, repéré PENDANT le flux : on coupe
            // tout de suite. Balayage fenêtré après le précédent, seulement
            // quand le morceau peut ouvrir un motif.
            let mut hit = false;
            if ((self.cfg.calls_on && self.cfg.pattern_retries < MAX_PATTERN_RETRIES)
                || self.cfg.tool_choice_none)
                && trigger
            {
                hit = self
                    .cfg
                    .patterns
                    .textual_tool_call_from(&self.content, self.retry_scanned);
                self.retry_scanned = self.content.len();
            }
            if hit {
                if self.cfg.tool_choice_none {
                    self.none_leak = true;
                } else {
                    self.pattern_hit = true;
                }
                return false;
            }
            return true;
        }
        // <think> ouvert par le gabarit : le contenu part EN DIRECT comme
        // réponse, sauf une fin qui pourrait commencer un « </think> ».
        self.think_tail.push_str(&c);
        if let Some(i) = self.think_tail.find(THINK_CLOSE) {
            let s = std::mem::take(&mut self.think_tail);
            let reason = &s[..i];
            let after = s[i + THINK_CLOSE.len()..].trim_start_matches(['\r', '\n']);
            self.think_open = false;
            if !reason.is_empty() && !self.send(StreamEvent::Reasoning(reason.to_string()), emit) {
                self.aborted = true;
                return false;
            }
            if !after.is_empty() && !self.send(StreamEvent::Content(after.to_string()), emit) {
                self.aborted = true;
                return false;
            }
            return true;
        }
        let mut cut = self.think_tail.len() as isize - (THINK_CLOSE.len() as isize - 1);
        while cut > 0 && !self.think_tail.is_char_boundary(cut as usize) {
            cut -= 1;
        }
        if cut > 0 {
            let rest = self.think_tail.split_off(cut as usize);
            let out = std::mem::replace(&mut self.think_tail, rest);
            if !self.send(StreamEvent::Content(out), emit) {
                self.aborted = true;
                return false;
            }
        }
        true
    }

    /// Fin de lecture (EOF, coupure ou arrêt) : le reliquat retenu par la
    /// garde « </think> » part comme réponse, puis les stats sont complétées
    /// (`echoed`, TTFT, et sans `timings` un débit mesuré ici, émis par le
    /// rappel).
    pub fn finish<F: FnMut(StreamEvent) -> bool>(mut self, emit: &mut F) -> StreamOutcome {
        if !self.aborted && self.think_open && !self.think_tail.is_empty() {
            let tail = std::mem::take(&mut self.think_tail);
            let t = tail.trim_start_matches(['\r', '\n']).to_string();
            self.send(StreamEvent::Content(t), emit);
        }
        let echo_text = if self.cfg.echo_on && self.saw_reasoning_field {
            std::mem::take(&mut self.echo_buf)
        } else {
            String::new()
        };
        if !echo_text.is_empty() && (!self.tool_calls.is_empty() || self.cfg.echo_keeps_past) {
            self.stats.echoed = true;
        }
        let ms = |d: std::time::Duration| d.as_millis() as i64;
        if let Some(tf) = self.t_first {
            let ttft = ms(tf.saturating_duration_since(self.cfg.t_req));
            self.stats.ttft_ms = Some(ttft);
            if !self.saw_timings {
                // Décodage mesuré ici ; le 1er jeton tombe dans la lecture du prompt.
                let tl = self.t_last.unwrap_or(tf);
                let generated = if self.usage_gen == 0 {
                    self.gen_chunks // sans usage : un chunk ≈ un jeton
                } else {
                    self.usage_gen
                };
                let span = tl.saturating_duration_since(tf);
                self.stats.prompt_ms = ttft as f64;
                self.stats.gen_tokens = generated;
                self.stats.gen_ms = ms(span) as f64;
                let sec = span.as_secs_f64();
                if sec > 0.0 && generated > 1 {
                    self.stats.gen_per_second = (generated - 1) as f64 / sec;
                }
                emit(StreamEvent::Stats(self.stats.clone()));
            }
        }
        StreamOutcome {
            content: self.content,
            shown: self.shown,
            tool_calls: self.tool_calls,
            finish_reason: self.finish_reason,
            stats: self.stats,
            saw_timings: self.saw_timings,
            saw_reasoning_field: self.saw_reasoning_field,
            echo_text,
            sent_answer: self.sent_answer,
            sent_reasoning: self.sent_reasoning,
            typing_tool: self.typing_tool,
            aborted: self.aborted,
            pattern_hit: self.pattern_hit,
            none_leak: self.none_leak,
            preflight: match self.preflight {
                Preflight::Refused(r) => Some(r),
                _ => None,
            },
        }
    }
}

// ───────────────────────── Encodages façon Go ─────────────────────────

/// Mantisse (signe compris) et exposant décimal de la forme la plus courte.
fn sci_parts(f: f64) -> (String, i32) {
    let s = format!("{f:e}");
    match s.split_once('e') {
        Some((m, e)) => (m.to_string(), e.parse().unwrap_or(0)),
        None => (s, 0),
    }
}

fn go_exp(m: &str, e: i32, min_digits: usize) -> String {
    let sign = if e < 0 { '-' } else { '+' };
    format!("{m}e{sign}{:0w$}", e.unsigned_abs(), w = min_digits)
}

/// Nombre JSON comme `encoding/json` (float64) : 'f' le plus court, 'e' hors
/// de [1e-6, 1e21[ (« e-7 », « e+21 »).
fn go_json_float(f: f64) -> String {
    let a = f.abs();
    if a != 0.0 && !(1e-6..1e21).contains(&a) {
        let (m, e) = sci_parts(f);
        return go_exp(&m, e, if e < 0 { 1 } else { 2 });
    }
    format!("{f}")
}

/// `%v` d'un float64 (`%g` le plus court de strconv : forme 'e' si
/// l'exposant est < -4 ou >= 6, « 1e+06 »).
fn go_fmt_float(f: f64) -> String {
    let (m, e) = sci_parts(f);
    if !(-4..6).contains(&e) {
        return go_exp(&m, e, 2);
    }
    format!("{f}")
}

/// `fmt.Sprintf("%v", v)` d'une valeur décodée en `any`.
fn go_fmt_v(v: &Value) -> String {
    match v {
        Value::Null => "<nil>".into(),
        Value::Bool(b) => b.to_string(),
        Value::Number(n) => go_fmt_float(n.as_f64().unwrap_or(0.0)),
        Value::String(s) => s.clone(),
        Value::Array(a) => format!("[{}]", a.iter().map(go_fmt_v).collect::<Vec<_>>().join(" ")),
        Value::Object(o) => {
            let mut keys: Vec<&String> = o.keys().collect();
            keys.sort();
            let parts: Vec<String> = keys
                .into_iter()
                .map(|k| format!("{k}:{}", go_fmt_v(&o[k])))
                .collect();
            format!("map[{}]", parts.join(" "))
        }
    }
}

/// Chaîne JSON comme `encoding/json` (échappement HTML, U+2028/2029).
fn go_json_string(s: &str, out: &mut String) {
    out.push('"');
    for c in s.chars() {
        match c {
            '\\' => out.push_str("\\\\"),
            '"' => out.push_str("\\\""),
            '\u{8}' => out.push_str("\\b"),
            '\u{c}' => out.push_str("\\f"),
            '\n' => out.push_str("\\n"),
            '\r' => out.push_str("\\r"),
            '\t' => out.push_str("\\t"),
            '<' | '>' | '&' => out.push_str(&format!("\\u{:04x}", c as u32)),
            c if (c as u32) < 0x20 => out.push_str(&format!("\\u{:04x}", c as u32)),
            '\u{2028}' => out.push_str("\\u2028"),
            '\u{2029}' => out.push_str("\\u2029"),
            c => out.push(c),
        }
    }
    out.push('"');
}

/// `json.Marshal` d'une valeur décodée en `any` (nombres en float64, clés
/// triées).
fn go_marshal(v: &Value, out: &mut String) {
    match v {
        Value::Null => out.push_str("null"),
        Value::Bool(b) => out.push_str(if *b { "true" } else { "false" }),
        Value::Number(n) => out.push_str(&go_json_float(n.as_f64().unwrap_or(0.0))),
        Value::String(s) => go_json_string(s, out),
        Value::Array(a) => {
            out.push('[');
            for (i, x) in a.iter().enumerate() {
                if i > 0 {
                    out.push(',');
                }
                go_marshal(x, out);
            }
            out.push(']');
        }
        Value::Object(o) => go_marshal_object(o, out),
    }
}

fn go_marshal_object(o: &Map<String, Value>, out: &mut String) {
    let mut keys: Vec<&String> = o.keys().collect();
    keys.sort();
    out.push('{');
    for (i, k) in keys.into_iter().enumerate() {
        if i > 0 {
            out.push(',');
        }
        go_json_string(k, out);
        out.push(':');
        go_marshal(&o[k], out);
    }
    out.push('}');
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::chat::types::ToolFunction;
    use serde_json::json;
    use std::time::Duration;

    // ── Flux enregistrés des tests Go (sseChunk, sseReasoning, sseFinal…) ──

    fn sse_chunk(text: &str) -> String {
        format!("data: {{\"choices\":[{{\"delta\":{{\"content\":\"{text}\"}}}}]}}\n\n")
    }

    fn sse_reasoning(text: &str) -> String {
        format!("data: {{\"choices\":[{{\"delta\":{{\"reasoning_content\":\"{text}\"}}}}]}}\n\n")
    }

    fn sse_final(finish: &str, prompt: i64, generated: i64) -> String {
        format!(
            "data: {{\"choices\":[{{\"delta\":{{}},\"finish_reason\":\"{finish}\"}}]}}\n\n\
             data: {{\"choices\":[],\"timings\":{{\"prompt_n\":10,\"predicted_n\":{generated}}},\
             \"usage\":{{\"prompt_tokens\":{prompt},\"completion_tokens\":{generated}}}}}\n\n"
        )
    }

    const SSE_STOP: &str = "data: {\"choices\":[{\"delta\":{},\"finish_reason\":\"stop\"}]}\n\n";
    const SSE_DONE: &str = "data: [DONE]\n\n";
    const SSE_GLOB_STEP: &str = concat!(
        r#"data: {"choices":[{"delta":{"tool_calls":[{"index":0,"id":"g1","type":"function","function":{"name":"glob","arguments":"{\"pattern\":\"*.go\"}"}}]}}]}"#,
        "\n\n",
        r#"data: {"choices":[{"delta":{},"finish_reason":"tool_calls"}]}"#,
        "\n\n"
    );

    fn agent() -> StreamConfig {
        StreamConfig {
            calls_on: true,
            ..Default::default()
        }
    }

    /// Rejoue un corps SSE ligne par ligne (bufio.Scanner coupe sur '\n'),
    /// jusqu'à la coupure éventuelle, puis `finish`.
    fn replay(cfg: StreamConfig, body: &str) -> (Vec<StreamEvent>, StreamOutcome) {
        let mut evs = Vec::new();
        let mut emit = |ev: StreamEvent| {
            evs.push(ev);
            true
        };
        let mut p = StreamParser::new(cfg);
        for line in body.split('\n') {
            if !p.feed_line(line, Instant::now(), &mut emit) {
                break;
            }
        }
        let out = p.finish(&mut emit);
        (evs, out)
    }

    fn contents(evs: &[StreamEvent]) -> String {
        evs.iter()
            .filter_map(|e| match e {
                StreamEvent::Content(c) => Some(c.as_str()),
                _ => None,
            })
            .collect()
    }

    fn reasonings(evs: &[StreamEvent]) -> Vec<String> {
        evs.iter()
            .filter_map(|e| match e {
                StreamEvent::Reasoning(r) => Some(r.clone()),
                _ => None,
            })
            .collect()
    }

    fn last_stats(evs: &[StreamEvent]) -> Option<StatsEvent> {
        evs.iter().rev().find_map(|e| match e {
            StreamEvent::Stats(s) => Some(s.clone()),
            _ => None,
        })
    }

    fn tool_events(evs: &[StreamEvent]) -> Vec<ToolUsedEvent> {
        evs.iter()
            .filter_map(|e| match e {
                StreamEvent::ToolUsed(t) => Some(t.clone()),
                _ => None,
            })
            .collect()
    }

    fn obj(v: Value) -> Map<String, Value> {
        match v {
            Value::Object(o) => o,
            _ => Map::new(),
        }
    }

    fn marshal(v: &Value) -> String {
        let mut s = String::new();
        go_marshal(v, &mut s);
        s
    }

    const BACKSLASH: char = '\x5c';

    /// Échappement JSON `\uXXXX` attendu.
    fn esc(hex: &str) -> String {
        format!("{BACKSLASH}u{hex}")
    }

    /// Générateur reproductible (les tests Go utilisent math/rand à graine fixe).
    struct Rng(u64);

    impl Rng {
        fn new(seed: u64) -> Self {
            Rng(seed.wrapping_mul(0x9E37_79B9_7F4A_7C15) | 1)
        }
        fn intn(&mut self, n: usize) -> usize {
            self.0 ^= self.0 << 13;
            self.0 ^= self.0 >> 7;
            self.0 ^= self.0 << 17;
            (self.0 % n as u64) as usize
        }
    }

    /// `chunked` : morceaux de 1 à max octets — prolongés jusqu'à une
    /// frontière de caractère (un &str ne peut pas couper un caractère ; les
    /// arguments réels arrivent toujours en chaînes JSON entières).
    fn chunked(s: &str, r: &mut Rng, max: usize) -> Vec<String> {
        let mut out = Vec::new();
        let mut s = s;
        while !s.is_empty() {
            let mut n = (1 + r.intn(max)).min(s.len());
            while !s.is_char_boundary(n) {
                n += 1;
            }
            out.push(s[..n].to_string());
            s = &s[n..];
        }
        out
    }

    // ── code_alias_test.go ──

    fn outils(noms: &[&str]) -> Vec<Tool> {
        noms.iter()
            .map(|n| Tool {
                kind: "function".into(),
                function: ToolFunction {
                    name: n.to_string(),
                    ..Default::default()
                },
            })
            .collect()
    }

    /// TestReparationDesAppelsHallucines
    #[test]
    fn reparation_des_appels_hallucines() {
        let tools = outils(&["read", "edit", "bash", "subagent"]);
        let cas = [
            (
                "read_file",
                r#"{"path":"a.go"}"#,
                "read",
                json!({"file": "a.go"}),
            ),
            (
                "str_replace",
                r#"{"file_path":"a.go","old_string":"x","new_string":"y"}"#,
                "edit",
                json!({"file": "a.go", "old": "x", "new": "y"}),
            ),
            (
                "run_command",
                r#"{"cmd":"ls"}"#,
                "bash",
                json!({"command": "ls"}),
            ),
            (
                "edit",
                r#"{"file":"a.go","old_str":"x","new":"y"}"#,
                "edit",
                json!({"file": "a.go", "old": "x", "new": "y"}),
            ),
            (
                "code_reviewer",
                r#"{"prompt":"relis"}"#,
                "subagent",
                json!({"role": "code-reviewer", "task": "relis"}),
            ),
        ];
        for (name, args, want_name, want_args) in cas {
            let mut tc = ToolCall::default();
            tc.function.name = name.into();
            tc.function.arguments = args.into();
            assert!(repair_tool_call(&mut tc, &tools), "{name} : non réparé");
            assert_eq!(tc.function.name, want_name, "{name}");
            assert_eq!(call_args(&tc.function.arguments), obj(want_args), "{name}");
        }
        // Outil cible absent de ce tour, ou appel déjà correct : intact.
        for (name, args) in [
            ("write_file", r#"{"path":"a"}"#),
            ("read", r#"{"file":"a"}"#),
        ] {
            let mut tc = ToolCall::default();
            tc.function.name = name.into();
            tc.function.arguments = args.into();
            let before = tc.clone();
            assert!(
                !repair_tool_call(&mut tc, &tools),
                "modifié à tort : {tc:?}"
            );
            assert_eq!(tc, before);
        }
    }

    // ── code_retry_test.go ──

    /// TestAppelOutilTextuelDetecte
    #[test]
    fn appel_outil_textuel_detecte() {
        let p = RetryPatterns::builtin();
        for s in [
            "<tool_call>{\"name\":\"bash\"}</tool_call>",
            "Je vais lancer default_api:bash pour vérifier.",
            "default_api.run_shell(command='ls')",
            "functions.bash({\"command\": \"ls\"})",
            "```tool_code\nprint('x')\n```",
            "{\"name\": \"bash\", \"arguments\": {\"command\": \"ls\"}}",
        ] {
            assert!(p.textual_tool_call(s), "non détecté : {s:?}");
        }
    }

    /// TestReponseNormaleNonRelancee
    #[test]
    fn reponse_normale_non_relancee() {
        let p = RetryPatterns::builtin();
        for s in [
            "Voici la réponse : le fichier contient trois fonctions.",
            "```go\nfunc main() {}\n```",
            "Le JSON de config : {\"name\": \"loki\", \"port\": 8090}",
            "La fonction bash() de ce script accepte un paramètre.",
            "",
        ] {
            assert!(!p.textual_tool_call(s), "relance à tort : {s:?}");
        }
    }

    /// TestAppelOutilQwenXMLDetecte
    #[test]
    fn appel_outil_qwen_xml_detecte() {
        let p = RetryPatterns::builtin();
        let s = "Je regarde.\n<function=bash>\n<parameter=command>ls -la</parameter>\n</function>";
        let snip = p.snippet(s);
        assert!(snip.starts_with("<function=bash>"), "extrait = {snip:?}");
        assert!(
            !p.textual_tool_call("Un <div class=\"x\"> et un <param name=\"a\"> en HTML."),
            "HTML ordinaire pris pour un appel d'outil"
        );
    }

    /// TestAppelTextuelCoupeLeFlux (partie analyse) : le flux est coupé sur
    /// l'appel écrit en texte, la suite n'est jamais émise, et la relance cite
    /// l'extrait fautif.
    #[test]
    fn appel_textuel_coupe_le_flux() {
        let body = sse_chunk("Je lance <tool_call>") + &sse_chunk("FIN-INUTILE") + SSE_STOP;
        let (evs, out) = replay(agent(), &body);
        assert!(out.pattern_hit && !out.none_leak);
        assert!(!contents(&evs).contains("FIN-INUTILE"), "flux non coupé");
        assert!(out.read_error_benign());
        let second = retry_corrective(&RetryPatterns::builtin().snippet(&out.content));
        assert!(
            second.contains("<tool_call>") && second.contains("WRITTEN AS TEXT"),
            "{second:?}"
        );
        // Budget de relances épuisé : plus de coupure, le texte va au bout.
        let cfg = StreamConfig {
            pattern_retries: MAX_PATTERN_RETRIES,
            ..agent()
        };
        let (evs, out) = replay(cfg, &body);
        assert!(!out.pattern_hit && contents(&evs).ends_with("FIN-INUTILE"));
    }

    // ── perf_log_test.go ──

    const LLAMA_FINAL_CHUNK: &str = concat!(
        r#"{"choices":[],"created":1,"id":"x","model":"m","object":"chat.completion.chunk","#,
        r#""usage":{"completion_tokens":120,"prompt_tokens":41484,"total_tokens":41604,"prompt_tokens_details":{"cached_tokens":41230}},"#,
        r#""timings":{"cache_n":41230,"prompt_n":254,"prompt_ms":310.2,"prompt_per_token":1.2,"prompt_per_second":818.8,"#,
        r#""predicted_n":120,"predicted_ms":2400,"predicted_per_token":20,"predicted_per_second":50,"draft_n":90,"draft_n_accepted":71}}"#
    );

    /// TestPerfWireDecode
    #[test]
    fn perf_wire_decode() {
        /// (cas, chunk, cache, brouillon, accepté)
        type Cas = (&'static str, String, Option<i64>, Option<i64>, Option<i64>);
        let cas: [Cas; 8] = [
            (
                "chunk final llama.cpp",
                LLAMA_FINAL_CHUNK.into(),
                Some(41230),
                Some(90),
                Some(71),
            ),
            // Sans brouillon, llama.cpp n'émet pas draft_n : inconnu, pas 0.
            (
                "sans brouillon",
                r#"{"timings":{"cache_n":12,"prompt_n":3}}"#.into(),
                Some(12),
                None,
                None,
            ),
            // Tout recalculé : un 0 CONNU, qu'il faut pouvoir montrer.
            (
                "cache vide",
                r#"{"timings":{"cache_n":0,"prompt_n":3000}}"#.into(),
                Some(0),
                None,
                None,
            ),
            // API tierce : seulement le format OpenAI.
            (
                "usage seul",
                r#"{"usage":{"prompt_tokens":900,"prompt_tokens_details":{"cached_tokens":512}}}"#
                    .into(),
                Some(512),
                None,
                None,
            ),
            (
                "moteur muet",
                r#"{"usage":{"prompt_tokens":900}}"#.into(),
                None,
                None,
                None,
            ),
            // Types de travers : lu si c'est un nombre, sinon inconnu.
            (
                "types de travers",
                r#"{"timings":{"cache_n":"abc","draft_n":"12","draft_n_accepted":7.0}}"#.into(),
                None,
                Some(12),
                Some(7),
            ),
            // Octets parasites après la réponse : la première valeur compte.
            (
                "octets parasites",
                r#"{"timings":{"cache_n":12}}"#.to_string() + "\nxyz",
                Some(12),
                None,
                None,
            ),
            (
                "structure de travers",
                r#"{"timings":"nope","usage":{"prompt_tokens_details":{"cached_tokens":5.9}}}"#
                    .into(),
                Some(5),
                None,
                None,
            ),
        ];
        for (name, data, cache, draft, accept) in cas {
            let mut s = StatsEvent::default();
            apply_perf(&mut s, &decode_perf_wire(&data));
            assert_eq!(
                (s.cache_tokens, s.draft_n, s.draft_accepted),
                (cache, draft, accept),
                "{name}"
            );
        }
    }

    /// TestStreamChunkIgnoresOddTelemetry
    #[test]
    fn stream_chunk_ignores_odd_telemetry() {
        let data = concat!(
            r#"{"choices":[{"delta":{"content":"fin"},"finish_reason":"stop"}],"#,
            r#""usage":{"prompt_tokens":500,"completion_tokens":3,"prompt_tokens_details":{"cached_tokens":480.5}},"#,
            r#""timings":{"prompt_n":20,"predicted_n":3,"draft_n":"x","cache_n":480.0}}"#
        );
        let c = decode_stream_chunk(data).expect("chunk jeté");
        assert_eq!(c.choices.len(), 1);
        assert_eq!(c.choices[0].delta.content, "fin");
        assert_eq!(c.choices[0].finish_reason, "stop");
        assert_eq!(c.usage.as_ref().map(|u| u.prompt_tokens), Some(500));
        let mut s = StatsEvent::default();
        apply_perf(&mut s, &decode_perf_wire(data));
        assert_eq!((s.cache_tokens, s.draft_n), (Some(480), None));
    }

    /// TestRunChatPerfFinalStats (partie analyse) : le dernier Stats porte la
    /// télémétrie, le texte est intact, la complétion est complète.
    #[test]
    fn run_chat_perf_final_stats() {
        let body = sse_chunk("bonjour")
            + r#"data: {"choices":[{"delta":{"content":" toi"},"finish_reason":"stop"}],"usage":{"prompt_tokens":500,"completion_tokens":2,"prompt_tokens_details":{"cached_tokens":480.5}},"timings":{"prompt_n":20,"prompt_ms":10,"prompt_per_second":2000,"predicted_n":2,"predicted_ms":40,"predicted_per_second":50,"draft_n":"x"}}"#
            + "\n\n"
            + SSE_DONE;
        let seen = Arc::new(std::sync::Mutex::new(Vec::new()));
        let seen2 = seen.clone();
        let cfg = StreamConfig {
            cache_hint: Some(Box::new(move |p, c, ok| {
                seen2.lock().unwrap().push((p, c, ok));
                "conseil".into()
            })),
            ..Default::default()
        };
        let (evs, out) = replay(cfg, &body);
        assert_eq!(contents(&evs), "bonjour toi");
        let last = last_stats(&evs).expect("stats");
        assert_eq!(last.prompt_tokens_total, 500);
        assert_eq!(last.cache_tokens, Some(480));
        assert_eq!(last.cache_hint, "conseil");
        assert_eq!(*seen.lock().unwrap(), vec![(500, 480, true)]);
        // Le conseil ne reste pas dans les stats accumulées.
        assert!(out.stats.cache_hint.is_empty());
        assert_eq!(out.stats.prompt_tokens, 20);
        assert_eq!(out.stats.gen_tokens, 2);
        assert!(out.stats.ttft_ms.is_some());
        assert!(out.is_complete(false));
    }

    /// TestRunChatPerfCutStreamIncomplete : flux coupé, ni cache ni total.
    #[test]
    fn run_chat_perf_cut_stream_incomplete() {
        let (_, out) = replay(StreamConfig::default(), &sse_chunk("début"));
        assert!(!out.is_complete(true));
        assert!(!out.read_error_benign());
    }

    // ── llm_stream_cut_test.go (partie analyse) ──

    /// TestFluxCoupeRemonteUneErreur / TestFluxCompletNeRemonteRien : le texte
    /// reçu avant la coupure est émis ; sans finish_reason, la coupure n'est
    /// pas bénigne (la boucle remonte l'erreur).
    #[test]
    fn flux_coupe_et_flux_complet() {
        let (evs, out) = replay(StreamConfig::default(), &sse_chunk("début de r"));
        assert_eq!(contents(&evs), "début de r");
        assert!(!out.read_error_benign());
        let (evs, out) = replay(
            StreamConfig::default(),
            &(sse_chunk("réponse complète") + SSE_DONE),
        );
        assert_eq!(contents(&evs), "réponse complète");
        assert_eq!(out.shown, "réponse complète");
        assert!(out.sent_answer && !out.sent_reasoning);
    }

    // ── chat_vision_tool_test.go ──

    /// TestLeCheminDeLImageRemonteJusquALOutil
    #[test]
    fn le_chemin_de_l_image_remonte_jusqu_a_l_outil() {
        let args = obj(json!({"file": "captures/bug.png"}));
        assert_eq!(tool_call_label("see_image", &args), "captures/bug.png");
    }

    /// TestLibellesDesAutresOutilsInchanges
    #[test]
    fn libelles_des_autres_outils_inchanges() {
        for (tool, key, val, want) in [
            ("bash", "command", "ls -la", "ls -la"),
            ("read", "file", "main.go", "main.go"),
            ("web_search", "query", "météo", "météo"),
            ("grep", "pattern", "TODO", "TODO"),
            ("recall", "id", "b12", "b12"),
            ("git_clone", "url", "https://x/y", "https://x/y"),
            ("outil_inconnu", "file", "x", ""),
        ] {
            let args = obj(json!({ key: val }));
            assert_eq!(tool_call_label(tool, &args), want, "{tool}");
        }
        let args = obj(json!({"url": "https://x", "pattern": "p"}));
        assert_eq!(tool_call_label("web_grep", &args), "p @ https://x");
        let args = obj(json!({"action": "add", "name": "poids"}));
        assert_eq!(tool_call_label("tracker", &args), "add poids");
        // Argument absent ou du mauvais type : chaîne vide, jamais de panique.
        assert_eq!(tool_call_label("read", &obj(json!({"file": 42}))), "");
        assert_eq!(tool_call_label("bash", &call_args("null")), "");
    }

    /// Libellés tolérants au type (`str`) et outils MCP (`mcpArgLabel`).
    #[test]
    fn libelles_tracker_et_mcp() {
        let l = |v: Value| tool_call_label("tracker", &obj(v));
        assert_eq!(l(json!({"action": 2.5, "name": 1e6})), "2 1000000");
        assert_eq!(l(json!({"action": true})), "true");
        assert_eq!(
            l(json!({"name": [1, "a", 1234567.0, {"b": null}]})),
            "[1 a 1.234567e+06 map[b:<nil>]]"
        );
        assert_eq!(l(json!({})), "");
        let m = |v: Value| tool_call_label("mcp__srv__x", &obj(v));
        assert_eq!(m(json!({})), "");
        assert_eq!(m(json!({"name": "n", "path": "p"})), "p");
        let want = format!(
            "{{\"a\":1e+21,\"path\":\"\",\"z\":\"{}{}{}\"}}",
            esc("003c"),
            esc("0026"),
            esc("003e")
        );
        assert_eq!(m(json!({"path": "", "z": "<&>", "a": 1e21})), want);
        let long = m(json!({"z": "é".repeat(200)}));
        assert_eq!(long.chars().count(), 121);
        assert!(long.ends_with('…'));
        assert_eq!(tool_call_label("autre__x", &obj(json!({"path": "p"}))), "");
    }

    // ── stream_hotpath_test.go ──

    /// checkArgPreview : à chaque préfixe, ArgPreview = preview_arg_done (à une
    /// barre oblique finale près).
    fn check_arg_preview(args: &str, key: &str, chunks: &[String]) {
        let mut a = ArgPreview::new(key);
        let mut prefix = String::new();
        for c in chunks {
            prefix.push_str(c);
            a.update(&prefix);
            let (want, want_done) = preview_arg_done(&prefix, key);
            let mut got = a.value().into_owned();
            if a.phase == 3 && a.pos + 1 == prefix.len() && prefix.as_bytes()[a.pos] == b'\\' {
                got.push('\\');
            }
            assert!(
                got == want && a.done() == want_done,
                "args={args:?} préfixe={prefix:?} : argPreview=({got:?},{}), previewArgDone=({want:?},{want_done})",
                a.done()
            );
            assert_eq!(a.value().matches('\n').count(), a.newlines());
            assert_eq!(
                body_line_count(&a.value()),
                a.line_count(),
                "valeur {:?}",
                a.value()
            );
        }
    }

    /// TestArgPreviewMatchesPreviewArgDone (+ graines de FuzzArgPreview)
    #[test]
    fn arg_preview_matches_preview_arg_done() {
        let mut r = Rng::new(7);
        let alphabet = [
            "a", "é", "\n", "\t", "\r", "\\", "\"", "<", "&", " ", "/", "\u{2028}", "x", "content",
            ":", "{",
        ];
        let mut cases = Vec::new();
        for _ in 0..300 {
            let v: String = (0..r.intn(200))
                .map(|_| alphabet[r.intn(alphabet.len())])
                .collect();
            cases.push(marshal(&json!({"file": "a/b.go", "content": v})));
            // Ordre inverse et clé citée avant la vraie : même règle de première occurrence.
            let esc = v.replace('"', "\\\"");
            cases.push(format!(r#"{{"content"  :  "{esc}","file":"x"}}"#));
            cases.push(format!(
                r#"{{"note":"le champ \"content\" vient après","content":"{esc}"}}"#
            ));
        }
        for s in [
            r#"{"content":"été \\u0041 fin"}"#,
            r#"{"content":"ligne1\nligne2\\"#,
            r#"{"content":"#,
            r#"{"cont"#,
            r#"{"content":""#,
            r#"{"content":"x"}"#,
            "",
        ] {
            cases.push(s.to_string());
        }
        for args in &cases {
            for max in [1, 3, 17, 4096] {
                check_arg_preview(args, "content", &chunked(args, &mut r, max));
            }
        }
        // Graines du fuzz Go.
        for (args, seed) in [
            (r#"{"file":"a","content":"x\ny\\\"zA"}"#, 1),
            (r#"{"content":"a\\"#, 2),
            (r#"{"content" : "x", "content":"y"}"#, 3),
        ] {
            check_arg_preview(args, "content", &chunked(args, &mut Rng::new(seed), 9));
        }
    }

    /// TestBodyTail
    #[test]
    fn body_tail_borne() {
        let lines = |n: usize, w: usize| -> String {
            (0..n)
                .map(|i| "x".repeat(w) + &i.to_string() + "\n")
                .collect()
        };
        let long = "é".repeat(5000); // une seule ligne de 10 000 octets
        for (name, input, cut, max_line) in [
            ("vide", String::new(), false, 0),
            ("court", "a\nb\nc".to_string(), false, 3),
            ("40 lignes pile", lines(39, 3) + "fin", false, 40),
            (
                "beaucoup de lignes",
                lines(500, 3) + "fin",
                true,
                BODY_TAIL_LINES,
            ),
            ("lignes larges", lines(100, 300), true, BODY_TAIL_LINES),
            ("ligne seule énorme", long, true, 1),
        ] {
            let (got, c) = body_tail(&input);
            assert!(c == cut && input.ends_with(got), "{name} : cut={c}");
            assert!(
                got.len() <= BODY_TAIL_BYTES,
                "{name} : {} octets",
                got.len()
            );
            let n = got.matches('\n').count() + 1;
            assert!(got.is_empty() || n <= max_line, "{name} : {n} lignes");
            if c {
                let start = input.len() - got.len();
                assert!(
                    input.as_bytes()[start - 1] == b'\n' || name.contains("seule"),
                    "{name} : coupé en milieu de ligne"
                );
                assert!(!got.contains('\u{FFFD}'), "{name} : caractère coupé");
            }
        }
    }

    /// TestBodyLineCount
    #[test]
    fn body_line_count_comme_l_ui() {
        for (input, want) in [
            ("", 0),
            ("\n", 0),
            ("a", 1),
            ("a\n", 1),
            ("a\nb", 2),
            ("a\nb\n", 2),
            ("\n\n", 2),
        ] {
            assert_eq!(body_line_count(input), want, "{input:?}");
        }
    }

    /// TestWriteTypingBodyBounded (partie analyse) : les événements de frappe
    /// d'un gros write ne portent qu'une fin bornée du corps, avec le vrai
    /// nombre de lignes ; les arguments assemblés restent entiers.
    #[test]
    fn write_typing_body_bounded() {
        let content: String = (0..3000)
            .map(|i| format!("ligne numéro {i} du fichier\n"))
            .collect();
        let args = marshal(&json!({"file": "gros.txt", "content": content}));
        let mut body = String::new();
        let mut s = args.as_str();
        while !s.is_empty() {
            let mut n = 37.min(s.len());
            while !s.is_char_boundary(n) {
                n += 1;
            }
            let piece = marshal(&Value::String(s[..n].to_string()));
            s = &s[n..];
            body += &format!(
                r#"data: {{"choices":[{{"delta":{{"tool_calls":[{{"index":0,"id":"w1","type":"function","function":{{"name":"write","arguments":{piece}}}}}]}}}}]}}"#
            );
            body += "\n\n";
        }
        body += r#"data: {"choices":[{"delta":{},"finish_reason":"tool_calls"}]}"#;
        body += "\n\n";
        body += SSE_DONE;
        let (evs, out) = replay(agent(), &body);
        let (mut sent, mut last) = (0, 0);
        let mut last_ev = None;
        for tu in tool_events(&evs) {
            if !tu.typing || tu.body.is_empty() {
                continue;
            }
            assert!(
                tu.body.len() <= BODY_TAIL_BYTES,
                "corps de {} octets",
                tu.body.len()
            );
            assert!(
                tu.body_lines >= last,
                "body_lines recule : {} après {last}",
                tu.body_lines
            );
            last = tu.body_lines;
            sent += tu.body.len();
            last_ev = Some(tu);
        }
        let last_ev = last_ev.expect("aucun événement de frappe");
        assert!(
            last_ev.body_tail && last_ev.body_lines >= 2990,
            "{:?}",
            last_ev.body_lines
        );
        assert!(content.ends_with(&last_ev.body));
        assert!(
            sent <= 3000 * BODY_TAIL_BYTES,
            "{sent} octets de corps diffusés"
        );
        let calls = out.assemble_tool_calls(0, &outils(&["write"]));
        assert!(calls.bad_args.is_empty());
        assert_eq!(calls.calls.len(), 1);
        assert_eq!(calls.calls[0].function.arguments, args);
        assert_eq!(out.finish_reason, "tool_calls");
    }

    /// replayScan : un morceau sans caractère déclencheur n'est pas balayé.
    /// Rend l'indice du morceau qui coupe le flux.
    fn replay_scan(p: &RetryPatterns, chunks: &[String], windowed: bool) -> Option<usize> {
        let mut b = String::new();
        let mut scanned = 0;
        for (i, c) in chunks.iter().enumerate() {
            b.push_str(c);
            if !c.contains(['<', '`', '{', '[', '_', '.']) {
                continue;
            }
            let hit = if windowed {
                let h = p.textual_tool_call_from(&b, scanned);
                scanned = b.len();
                h
            } else {
                p.textual_tool_call(&b)
            };
            if hit {
                return Some(i);
            }
        }
        None
    }

    /// TestTextualToolCallWindowMatchesFullScan
    #[test]
    fn textual_tool_call_window_matches_full_scan() {
        let p = RetryPatterns::builtin();
        let mut r = Rng::new(11);
        let prose = [
            "Voici la suite de l'analyse, ligne par ligne. ",
            "Le fichier contient trois fonctions ; aucune n'est exportée.\n",
            "```go\nfunc main() { fmt.Println(\"x\") }\n```\n",
            "- point important\n",
            "le JSON {\"name\": \"loki\"} de config, ",
            "sans ponctuation du tout mais avec des mots très longs ",
            "\n\n",
            "Un <div class=\"x\"> en HTML. ",
            "été à la plage ",
        ];
        let filler = |r: &mut Rng, n: usize| {
            let mut b = String::new();
            while b.len() < n {
                b.push_str(prose[r.intn(prose.len())]);
            }
            b
        };
        let bad = [
            "<tool_call>{\"name\":\"bash\"}</tool_call>".to_string(),
            "\n{\"name\": \"bash\", \"arguments\": {}}".to_string(),
            "\n   \n  {\"name\":".to_string()
                + &" \n".repeat(400)
                + "\"mem_"
                + &"a".repeat(700)
                + "\"",
            "\n".to_string() + &" ".repeat(900) + "{\"name\": \"web_open\"",
            "<function=".to_string() + &"b".repeat(900) + ">",
            " functions.".to_string() + &"c".repeat(600) + &" ".repeat(300) + "(",
            "Je lance default_api:bash ".to_string(),
            "```tool_code\nprint(1)\n```".to_string(),
            "<parameter=command>".to_string(),
            "[TOOL_REQUEST]".to_string(),
        ];
        let neutral = [
            " milieu de ligne {\"name\": \"bash\"} ".to_string(), // `^` : début de ligne seulement
            "x".repeat(800) + " {\"name\": \"bash\"",
            "<tool_cal> presque".to_string(),
        ];
        let mut texts = Vec::new();
        for i in 0..120 {
            let hl = 500 + r.intn(5000);
            let head = filler(&mut r, hl);
            let tl = r.intn(1500);
            let tail = filler(&mut r, tl);
            match i % 3 {
                0 => texts.push(head + &bad[r.intn(bad.len())] + &tail),
                1 => texts.push(head + &neutral[r.intn(neutral.len())] + &tail),
                _ => texts.push(head + &tail),
            }
        }
        // Motif à cheval sur un morceau sans caractère déclencheur.
        let lead = filler(&mut r, 3000);
        texts.push(lead.clone() + "<tool_call> puis du texte sans rien");
        let (mut hits, mut misses) = (0, 0);
        for (ti, s) in texts.iter().enumerate() {
            for max in [3, 23, 200] {
                let ch = if ti == texts.len() - 1 {
                    let mut ch = chunked(&lead, &mut r, max);
                    for x in ["<tool", "_call", ">", " puis du texte", " sans rien"] {
                        ch.push(x.to_string());
                    }
                    ch
                } else {
                    chunked(s, &mut r, max)
                };
                let (w, f) = (replay_scan(&p, &ch, true), replay_scan(&p, &ch, false));
                assert_eq!(w, f, "fenêtré ≠ complet (taille {}, max {max})", s.len());
                if f.is_some() {
                    hits += 1;
                } else {
                    misses += 1;
                }
            }
        }
        assert!(
            hits > 0 && misses > 0,
            "corpus déséquilibré : {hits} coupures, {misses} sans"
        );
    }

    /// TestRetryScanStartWindows
    #[test]
    fn retry_scan_start_windows() {
        let s = "Une phrase ordinaire, avec sa ponctuation.\n".repeat(500);
        let start = retry_scan_start(&s, s.len());
        assert!(
            start != 0 && s.len() - start <= 2 * RETRY_SCAN_MARGIN,
            "fenêtre de {} octets",
            s.len() - start
        );
        assert_eq!(
            s.as_bytes()[start - 1],
            b'\n',
            "la fenêtre ne démarre pas en début de ligne"
        );
        // Une ligne sans fin plus longue que le recul permis : balayage complet.
        assert_eq!(retry_scan_start(&"a b ".repeat(20000), 80000), 0);
    }

    /// La surcharge `retry_patterns` : tableau JSON de regex du Go, chacune
    /// en `(?mi)`, sémantique du Go (classes et limites de mot ASCII).
    #[test]
    fn surcharge_retry_patterns() {
        for raw in ["", "null", "[]", "[\"a\", 1]", "\"x\"", "[\"a\"] x"] {
            assert!(RetryPatterns::from_override(raw).is_none(), "{raw}");
        }
        let p = RetryPatterns::from_override(r#"["^oups", "[", "\\bdo_\\w+\\("]"#).unwrap();
        assert!(p.is_custom());
        assert_eq!(p.len(), 2, "la regex illisible est sautée");
        assert!(p.textual_tool_call("Bonjour\nOUPS !"));
        assert!(p.textual_tool_call("éxécute do_it(1)"));
        assert_eq!(
            p.snippet("puis do_it(1) et la suite"),
            "do_it(1) et la suite"
        );
        assert!(!p.textual_tool_call("ado_it(1)"));
        // Classes du Go : ASCII.
        let m = |pat: &str, s: &str| {
            compile_go_regex(&format!("(?mi){pat}"))
                .unwrap()
                .find(s)
                .map(|m| m.as_str().to_string())
        };
        assert_eq!(m(r"\w+", "été"), Some("t".into()));
        assert_eq!(m(r"\bfoo\b", "éfoo"), Some("foo".into()));
        assert_eq!(m(r"\Bfoo", "éfoo"), None);
        assert_eq!(m(r"\d+", "x٣42"), Some("42".into()));
        assert_eq!(m(r"\s+", "a\u{a0} \tb"), Some(" \t".into()));
        assert_eq!(m(r"\S+", "\u{a0}a b"), Some("\u{a0}a".into()));
        assert_eq!(m(r"[\w-]+", "é-a_b c"), Some("-a_b".into()));
        assert_eq!(m(r"[^\s]+", " ab "), Some("ab".into()));
        assert_eq!(m(r"[\W]", "aé"), Some("é".into()));
        assert_eq!(m(r"[\d\s]+", "a1 2b"), Some("1 2".into()));
        assert_eq!(m(r"[\D]", "1x"), Some("x".into()));
        // Texte littéral, dans et hors d'une classe.
        assert_eq!(m(r"\Qa.b\E", "axb a.b"), Some("a.b".into()));
        assert_eq!(m(r"\Q(x", "a(x"), Some("(x".into()));
        // Le Go refuse \Q dans une classe.
        assert_eq!(go_regex(r"[\Q]-\E]+"), None);
        // Dans une classe, « [ », « && », « -- » et « ~~ » sont littéraux.
        assert_eq!(m(r"[a[]+", "x[a["), Some("[a[".into()));
        assert_eq!(m(r"[a&&b]+", "x&ab"), Some("&ab".into()));
        // « !-- » : l'intervalle de « ! » à « - » pour le Go.
        assert_eq!(m(r"[!--]+", "a!#-b"), Some("!#-".into()));
        assert_eq!(m(r"[~~a]+", "x~a"), Some("~a".into()));
        assert_eq!(m(r"[]a]+", "x]a"), Some("]a".into()));
        assert_eq!(m(r"[[:alpha:]]+", "1abc"), Some("abc".into()));
        assert_eq!(m(r"[^[:alpha:]]+", "ab12"), Some("12".into()));
        // Le reste passe tel quel.
        assert_eq!(
            go_regex(r"\pL\.x{2}(?s:.)").as_deref(),
            Some(r"\pL\.x{2}(?s:.)")
        );
    }

    /// `(?mi)\Aoups` : motif de surcharge ancré en tête.
    struct Oups;

    impl RetryPattern for Oups {
        fn find(&self, s: &str) -> Option<(usize, usize)> {
            (s.len() >= 4 && s.as_bytes()[..4].eq_ignore_ascii_case(b"oups")).then_some((0, 4))
        }
    }

    /// TestTextualToolCallFromCustomFullScan
    #[test]
    fn textual_tool_call_from_custom_full_scan() {
        let s = "oups.\n".to_string() + &"Une phrase, puis une autre.\n".repeat(400);
        let custom = RetryPatterns::custom(vec![Box::new(Oups)]);
        assert!(custom.is_custom());
        assert!(
            custom.textual_tool_call_from(&s, s.len() - 10),
            "motif ancré en tête manqué"
        );
        let windowed = RetryPatterns {
            pats: vec![Box::new(Oups)],
            custom: false,
        };
        assert!(
            !windowed.textual_tool_call_from(&s, s.len() - 10),
            "la fenêtre aurait dû le manquer (le test ne prouve rien sinon)"
        );
    }

    /// Repli de casse de `(?i)` : « ſ » vaut s, « K » (Kelvin) vaut k, y
    /// compris dans `\w` ; `\b` reste ASCII.
    #[test]
    fn motifs_repli_de_casse_go() {
        let p = RetryPatterns::builtin();
        assert!(p.textual_tool_call("FUNCTIONS.Bash (x)"));
        assert!(p.textual_tool_call("functionſ.x("));
        assert!(p.textual_tool_call("{\"NAME\": \"as\u{212A}\"}"));
        assert!(p.textual_tool_call("<TOOL_CALL>"));
        assert!(p.textual_tool_call("default_api:\u{17F}"));
        assert!(!p.textual_tool_call("mydefault_api:bash"), "\\b");
        assert!(p.textual_tool_call("é default_api:bash"));
        assert!(!p.textual_tool_call("default_api:"), "\\w+ vide");
        assert!(!p.textual_tool_call("<function=>"));
        assert!(!p.textual_tool_call("functions.x ;("));
        // `^\s*` traverse les lignes vides ; l'extrait part du début de ligne.
        assert_eq!(
            p.snippet("a\n \n\t{\"name\":\n \"git_log\"}"),
            "{\"name\":\n \"git_log\"}"
        );
        assert!(!p.textual_tool_call("a {\"name\": \"bash\"}"));
        assert!(!p.textual_tool_call("{\"name\": \"mem_\"}"));
        // \v n'est pas un blanc pour Go.
        assert!(!p.textual_tool_call("\u{b}{\"name\": \"bash\"}"));
    }

    // ── llm_resume_test.go (partie analyse) ──

    /// TestAppelsParallelesSuiventLIndex
    #[test]
    fn appels_paralleles_suivent_l_index() {
        let body = concat!(
            r#"data: {"choices":[{"delta":{"tool_calls":[{"index":0,"id":"a","type":"function","function":{"name":"glob","arguments":"{\"pattern\":\"*.go\"}"}}]}}]}"#,
            "\n\n",
            r#"data: {"choices":[{"delta":{"tool_calls":[{"index":1,"id":"b","type":"function","function":{"name":"grep","arguments":"{\"pattern\":\"rien\"}"}}]}}]}"#,
            "\n\n",
            r#"data: {"choices":[{"delta":{},"finish_reason":"tool_calls"}]}"#,
            "\n\ndata: [DONE]\n\n"
        );
        let (_, out) = replay(agent(), body);
        let a = out.assemble_tool_calls(0, &outils(&["glob", "grep"]));
        let got: Vec<(&str, &str, &str)> = a
            .calls
            .iter()
            .map(|c| {
                (
                    c.id.as_str(),
                    c.function.name.as_str(),
                    c.function.arguments.as_str(),
                )
            })
            .collect();
        assert_eq!(
            got,
            vec![
                ("a", "glob", r#"{"pattern":"*.go"}"#),
                ("b", "grep", r#"{"pattern":"rien"}"#)
            ]
        );
        assert!(
            a.calls
                .iter()
                .all(|c| c.kind == "function" && c.index.is_none())
        );
    }

    /// TestDebitMesureSansTimings (partie analyse) : sans `timings`, le débit
    /// de décodage est mesuré ici.
    #[test]
    fn debit_mesure_sans_timings() {
        let t0 = Instant::now();
        let at = |ms: u64| t0 + Duration::from_millis(ms);
        let mut evs = Vec::new();
        let mut emit = |ev: StreamEvent| {
            evs.push(ev);
            true
        };
        let mut p = StreamParser::new(StreamConfig {
            external: true,
            t_req: t0,
            ..Default::default()
        });
        for (ms, s) in [(10, "un "), (30, "deux "), (50, "trois")] {
            assert!(p.feed_line(sse_chunk(s).trim(), at(ms), &mut emit));
        }
        p.feed_line(SSE_STOP.trim(), at(52), &mut emit);
        p.feed_line(
            r#"data: {"choices":[],"usage":{"prompt_tokens":12,"completion_tokens":3,"total_tokens":15}}"#,
            at(55),
            &mut emit,
        );
        p.feed_line("data: [DONE]", at(56), &mut emit);
        let out = p.finish(&mut emit);
        let last = last_stats(&evs).expect("stats");
        assert_eq!(last.gen_tokens, 3);
        assert!(
            (last.gen_per_second - 50.0).abs() < 1e-9,
            "{}",
            last.gen_per_second
        );
        assert_eq!(last.gen_ms, 40.0);
        assert_eq!(last.prompt_ms, 10.0);
        assert_eq!(last.ttft_ms, Some(10));
        assert_eq!(last.prompt_tokens_total, 12);
        assert_eq!(out.stats, last);
        // Sans timings mais avec usage : complétion complète.
        assert!(out.is_complete(false));
    }

    // ── ctx_accounting_test.go (partie analyse) ──

    /// TestRaisonnementSepareCompte
    #[test]
    fn raisonnement_separe_compte() {
        let body = sse_reasoning("je ")
            + &sse_reasoning("réfléchis ")
            + &sse_reasoning("ici")
            + &sse_chunk("Bon")
            + &sse_chunk("jour")
            + &sse_final("stop", 100, 7)
            + SSE_DONE;
        let (evs, out) = replay(StreamConfig::default(), &body);
        assert_eq!(out.stats.reasoning_tokens, 3);
        assert_eq!(out.stats.ctx_after(), 104);
        assert_eq!(contents(&evs), "Bonjour");
        assert_eq!(reasonings(&evs).concat(), "je réfléchis ici");
        // Preset externe : son découpage ne dit rien du nombre de jetons.
        let (_, out) = replay(
            StreamConfig {
                external: true,
                ..Default::default()
            },
            &body,
        );
        assert_eq!(out.stats.reasoning_tokens, 0);
    }

    /// TestRaisonnementEnLigneNonCompte : <think> en ligne découpé chez nous,
    /// il reste dans le contenu et n'est pas retiré du compte.
    #[test]
    fn raisonnement_en_ligne_non_compte() {
        let body = sse_chunk("je pense")
            + &sse_chunk("</think>")
            + &sse_chunk("Réponse")
            + &sse_final("stop", 100, 6)
            + SSE_DONE;
        let cfg = StreamConfig {
            reasoning_on: true,
            ..Default::default()
        };
        let (evs, out) = replay(cfg, &body);
        // Comme en Go : la garde ne retient que 7 octets, le « j » part tout
        // de suite comme réponse, le reste devient le raisonnement.
        assert_eq!(reasonings(&evs), vec!["e pense".to_string()]);
        assert_eq!(contents(&evs), "jRéponse");
        assert_eq!(out.content, "je pense</think>Réponse");
        assert_eq!(out.stats.reasoning_tokens, 0);
        assert_eq!(out.stats.ctx_after(), 106);
    }

    // ── llm_reasoning_echo_test.go (partie analyse) ──

    /// TestEchoRenvoieLeRaisonnementSepare : le raisonnement séparé de l'étape
    /// d'outil est gardé (et compté dans le contexte suivant), celui de la
    /// réponse finale aussi.
    #[test]
    fn echo_renvoie_le_raisonnement_separe() {
        let cfg = || StreamConfig {
            echo_on: true,
            ..agent()
        };
        let step = sse_reasoning("je cherche ")
            + &sse_reasoning("les fichiers")
            + SSE_GLOB_STEP
            + SSE_DONE;
        let (_, out) = replay(cfg(), &step);
        assert_eq!(out.echo_text, "je cherche les fichiers");
        assert!(out.stats.echoed);
        assert_eq!(out.tool_calls.len(), 1);
        let fin = sse_reasoning("j'ai trouvé")
            + &sse_chunk("Voilà.")
            + &sse_final("stop", 120, 5)
            + SSE_DONE;
        let (_, out) = replay(cfg(), &fin);
        assert_eq!(out.echo_text, "j'ai trouvé");
        assert!(
            !out.stats.echoed,
            "pas d'appel et le gabarit ne garde pas le passé"
        );
        let (_, out) = replay(
            StreamConfig {
                echo_keeps_past: true,
                ..cfg()
            },
            &fin,
        );
        assert!(out.stats.echoed);
        // Clé absente : rien n'est capturé.
        let (_, out) = replay(agent(), &step);
        assert!(out.echo_text.is_empty() && !out.stats.echoed);
    }

    /// TestEchoJamaisDepuisLeDecoupageClient
    #[test]
    fn echo_jamais_depuis_le_decoupage_client() {
        let cfg = StreamConfig {
            echo_on: true,
            reasoning_on: true,
            ..agent()
        };
        let body = sse_chunk("je pense")
            + &sse_chunk("</think>")
            + &sse_chunk("je regarde")
            + SSE_GLOB_STEP;
        let (_, out) = replay(cfg, &body);
        assert_eq!(out.content, "je pense</think>je regarde");
        assert!(out.echo_text.is_empty());
        assert_eq!(out.tool_calls.len(), 1);
    }

    // ── code_preflight_test.go (partie analyse) ──

    fn write_chunk(args: &str) -> String {
        let esc = args.replace('"', "\\\"");
        format!(
            "data: {{\"choices\":[{{\"delta\":{{\"tool_calls\":[{{\"index\":0,\"id\":\"w1\",\"type\":\"function\",\"function\":{{\"name\":\"write\",\"arguments\":\"{esc}\"}}}}]}}}}]}}\n\n"
        )
    }

    /// TestPreVolCoupeLEcritureRefusee : refusé dès que le chemin est
    /// complet, le contenu n'arrive jamais.
    #[test]
    fn pre_vol_coupe_l_ecriture_refusee() {
        let body = write_chunk(r#"{"file":"main.go","#)
            + &write_chunk(r#""content":"package main // début"#)
            + &write_chunk(r#" FIN-JAMAIS-LUE"}"#)
            + r#"data: {"choices":[{"delta":{},"finish_reason":"tool_calls"}]}"#
            + "\n\n";
        let calls = Arc::new(std::sync::Mutex::new(Vec::new()));
        let c2 = calls.clone();
        let cfg = StreamConfig {
            preflight: Some(Box::new(move |file: &str, is_write: bool| {
                c2.lock().unwrap().push((file.to_string(), is_write));
                if is_write && file == "main.go" {
                    "[refusé] main.go existe et n'a pas été lu".into()
                } else {
                    String::new()
                }
            })),
            ..agent()
        };
        let (evs, out) = replay(cfg, &body);
        assert!(
            tool_events(&evs)
                .iter()
                .all(|t| !t.body.contains("FIN-JAMAIS-LUE"))
        );
        assert_eq!(
            out.preflight,
            Some(PreflightRefusal {
                name: "write".into(),
                id: "w1".into(),
                file: "main.go".into(),
                msg: "[refusé] main.go existe et n'a pas été lu".into(),
            })
        );
        assert_eq!(*calls.lock().unwrap(), vec![("main.go".to_string(), true)]);
        assert!(out.read_error_benign());
        // Chemin permis : vérifié une seule fois, le flux va au bout.
        let n = Arc::new(std::sync::Mutex::new(0));
        let n2 = n.clone();
        let cfg = StreamConfig {
            preflight: Some(Box::new(move |_: &str, _: bool| {
                *n2.lock().unwrap() += 1;
                String::new()
            })),
            ..agent()
        };
        let (evs, out) = replay(cfg, &body);
        assert_eq!(*n.lock().unwrap(), 1);
        assert!(out.preflight.is_none() && out.finish_reason == "tool_calls");
        // Le corps n'est diffusé qu'à la ligne : la fin sans saut de ligne
        // n'est pas réémise, mais l'appel assemblé est entier.
        assert!(
            !tool_events(&evs)
                .iter()
                .any(|t| t.body.contains("FIN-JAMAIS-LUE"))
        );
        assert!(
            out.tool_calls[&0]
                .function
                .arguments
                .ends_with(r#"FIN-JAMAIS-LUE"}"#)
        );
    }

    // ── llm_injected_test.go (partie analyse) ──

    /// TestRelance500ReplieSurLeCheminHistorique : sous tool_choice « none »,
    /// un appel (texte ou protocole) est une fuite qui coupe le flux, jamais
    /// un outil annoncé.
    #[test]
    fn relance_tool_choice_none_fuites() {
        let none = || StreamConfig {
            tool_choice_none: true,
            ..Default::default()
        };
        let leak = r#"data: {"choices":[{"delta":{"content":"<tool_call>"}}]}"#.to_string()
            + "\n\n"
            + SSE_STOP;
        let (_, out) = replay(none(), &leak);
        assert!(out.none_leak && !out.pattern_hit);
        let (evs, out) = replay(none(), SSE_GLOB_STEP);
        assert!(out.none_leak && tool_events(&evs).is_empty() && out.tool_calls.is_empty());
        let (_, out) = replay(none(), SSE_STOP);
        assert!(!out.none_leak && out.content.is_empty());
        let (_, out) = replay(none(), &(sse_chunk("voici") + SSE_STOP));
        assert!(!out.none_leak && out.content == "voici");
        // Outils coupés (pas de tool_choice none) : l'appel est ignoré, pas une fuite.
        let (evs, out) = replay(StreamConfig::default(), SSE_GLOB_STEP);
        assert!(!out.none_leak && out.tool_calls.is_empty() && tool_events(&evs).is_empty());
    }

    // ── Comportements de la boucle Go, sans test Go dédié ──

    /// `json.Unmarshal` dans streamChunk : un champ mal typé saute le chunk
    /// entier ; null est neutre ; clés insensibles à la casse.
    #[test]
    fn decodage_strict_comme_go() {
        for bad in [
            r#"{"choices":[{"delta":{"content":5}}]}"#,
            r#"{"choices":[{"delta":{"content":"a"}},{"delta":{"content":5}}]}"#,
            r#"{"timings":{"prompt_n":12.5}}"#,
            r#"{"usage":{"prompt_tokens":"500"}}"#,
            r#"{"choices":{}}"#,
            r#"{"choices":[{"delta":[]}]}"#,
            r#"{"choices":[{"delta":{"tool_calls":[{"index":1.0}]}}]}"#,
            r#"{"a":1} x"#,
            "[]",
            "\"x\"",
            "{",
        ] {
            assert_eq!(decode_stream_chunk(bad), None, "{bad}");
        }
        assert_eq!(decode_stream_chunk("null"), Some(StreamChunk::default()));
        let c = decode_stream_chunk(
            r#"{"choices":[{"delta":{"content":null},"finish_reason":null}],"timings":null}"#,
        )
        .unwrap();
        assert_eq!(c.choices[0], ChunkChoice::default());
        assert!(c.timings.is_none());
        let c = decode_stream_chunk(r#"{"Choices":[{"DELTA":{"Content":"x"}}]}"#).unwrap();
        assert_eq!(c.choices[0].delta.content, "x");
        // Une erreur glissée dans le flux est ignorée, comme en Go.
        let body =
            sse_chunk("a") + "data: {\"error\":{\"message\":\"boom\"}}\n\n" + &sse_chunk("b");
        let (evs, _) = replay(StreamConfig::default(), &body);
        assert_eq!(contents(&evs), "ab");
        // Lignes hors protocole.
        let (evs, _) = replay(
            StreamConfig::default(),
            ": ping\n\nevent: x\ndata:\n  data: {\"choices\":[{\"delta\":{\"content\":\"z\"}}]}\r\n",
        );
        assert_eq!(contents(&evs), "z");
    }

    /// Sans index, la position dans le chunk ; finish_reason « stop » garde
    /// les appels ; id de secours ; arguments cassés neutralisés (`badArgs`).
    #[test]
    fn assemblage_des_appels() {
        let body = concat!(
            r#"data: {"choices":[{"delta":{"tool_calls":[{"function":{"name":"bash","arguments":"{\"command\":\"python3 "}},{"function":{"name":"glob","arguments":""}}]}}]}"#,
            "\n\n",
            r#"data: {"choices":[{"delta":{"tool_calls":[{"index":2,"function":{"name":"bash","arguments":"{\"cmd\":"}},{"index":2,"function":{"arguments":"\"ls\"}"}}]}}]}"#,
            "\n\n",
            r#"data: {"choices":[{"delta":{"tool_calls":[{"index":3,"function":{"name":"x","arguments":"  "}}]}}]}"#,
            "\n\n",
            r#"data: {"choices":[{"delta":{},"finish_reason":"stop"}]}"#,
            "\n\n"
        );
        let (_, out) = replay(agent(), body);
        assert_eq!(out.finish_reason, "stop");
        let a = out.assemble_tool_calls(4, &outils(&["bash", "glob"]));
        let got: Vec<(&str, &str, &str)> = a
            .calls
            .iter()
            .map(|c| {
                (
                    c.id.as_str(),
                    c.function.name.as_str(),
                    c.function.arguments.as_str(),
                )
            })
            .collect();
        assert_eq!(
            got,
            vec![
                ("call_4_0", "bash", "{}"),
                ("call_4_1", "glob", "{}"),
                ("call_4_2", "bash", r#"{"command":"ls"}"#),
                ("call_4_3", "x", "{}"),
            ]
        );
        assert_eq!(a.bad_args, HashSet::from(["call_4_0".to_string()]));
    }

    /// Le rappel qui refuse arrête tout : plus rien n'est lu ni émis, le
    /// reliquat « </think> » n'est pas vidé.
    #[test]
    fn arret_par_le_rappel() {
        let mut evs = Vec::new();
        let mut emit = |ev: StreamEvent| {
            let stop = matches!(&ev, StreamEvent::Content(c) if c == "b");
            evs.push(ev);
            !stop
        };
        let mut p = StreamParser::new(StreamConfig::default());
        let now = Instant::now();
        assert!(p.feed_line(sse_chunk("a").trim(), now, &mut emit));
        assert!(!p.feed_line(sse_chunk("b").trim(), now, &mut emit));
        assert!(p.is_stopped());
        assert!(!p.feed_line(sse_chunk("c").trim(), now, &mut emit));
        let out = p.finish(&mut emit);
        assert!(out.aborted);
        assert_eq!(contents(&evs), "ab");
        assert_eq!(out.content, "ab");

        let mut evs = Vec::new();
        let mut emit = |ev: StreamEvent| {
            evs.push(ev);
            false
        };
        let mut p = StreamParser::new(StreamConfig {
            reasoning_on: true,
            ..Default::default()
        });
        // 12 octets : 5 partent, 7 retenus ; l'arrêt empêche le vidage final
        // (les stats de secours, elles, partent comme en Go).
        assert!(!p.feed_line(sse_chunk("Je vais lire").trim(), now, &mut emit));
        let out = p.finish(&mut emit);
        assert!(out.aborted);
        assert_eq!(contents(&evs), "Je va");
        assert!(last_stats(&evs).is_some());
    }

    /// Le reliquat retenu par la garde « </think> » part AVANT l'outil ; la
    /// frappe montre l'argument parlant au fil du flux.
    #[test]
    fn reliquat_avant_l_outil_et_frappe() {
        let cfg = StreamConfig {
            reasoning_on: true,
            ..agent()
        };
        let call = |args: &str| {
            let piece = marshal(&Value::String(args.into()));
            format!(
                "data: {{\"choices\":[{{\"delta\":{{\"tool_calls\":[{{\"index\":0,\"id\":\"c\",\"function\":{{\"name\":\"bash\",\"arguments\":{piece}}}}}]}}}}]}}\n\n"
            )
        };
        let body =
            sse_chunk("Je vais lire") + &call(r#"{"command":"ls"#) + &call(r#" -la"}"#) + &call("");
        let (evs, out) = replay(cfg, &body);
        let order: Vec<String> = evs
            .iter()
            .filter_map(|e| match e {
                StreamEvent::Content(c) => Some(format!("C:{c}")),
                StreamEvent::ToolUsed(t) => Some(format!("T:{}:{}", t.name, t.label)),
                _ => None,
            })
            .collect();
        assert_eq!(
            order,
            ["C:Je va", "C:is lire", "T:bash:ls", "T:bash:ls -la"]
        );
        assert_eq!(out.typing_tool.map(|t| t.label), Some("ls -la".to_string()));
        assert!(out.sent_answer);
        // Fin de flux sans outil : le reliquat est vidé, sauts de ligne de tête ôtés.
        let (evs, _) = replay(
            StreamConfig {
                reasoning_on: true,
                ..Default::default()
            },
            &sse_chunk("\\n\\nabc"),
        );
        assert_eq!(contents(&evs), "abc");
    }

    /// Encodage `json.Marshal` des arguments réparés.
    #[test]
    fn marshal_comme_go() {
        let v = json!({"b": 1e21, "a": 1.5e-7, "c": "<&>\u{2028}\u{1}\u{8}\u{7f}é", "d": [true, null, 100, 0.000001, 1e20, -0.0], "e": 12345678901234567890u64});
        let want = format!(
            "{{\"a\":1.5e-7,\"b\":1e+21,\"c\":\"{}{}{}{}{}{}b{}é\",\"d\":[true,null,100,0.000001,100000000000000000000,-0],\"e\":12345678901234567000}}",
            esc("003c"),
            esc("0026"),
            esc("003e"),
            esc("2028"),
            esc("0001"),
            BACKSLASH,
            char::from(0x7f)
        );
        assert_eq!(marshal(&v), want);
        assert_eq!(go_fmt_float(123456.0), "123456");
        assert_eq!(go_fmt_float(0.0001), "0.0001");
        assert_eq!(go_fmt_float(0.00001), "1e-05");
        assert_eq!(go_fmt_float(1e100), "1e+100");
    }
}