Lot 6 : routes du chat servies par la façade (LOKI_CHAT=rust)

Avec LOKI_CHAT=rust, la façade charge la discussion active au démarrage
et sert elle-même /api/chat (flux SSE : rejeu puis direct, battement de
cœur toutes les 4 s, trames regroupées), /api/chat/send, stop, reset,
state, compact, tool-result et /api/conversations{,/new,/switch,/rename,
/delete}, avec les réponses des handlers Go. /api/chat/mode et
/api/chat/criteria restent au Go ; la façade relaie puis journalise
l'état rendu, pour que tous les appareils suivent. Pièces jointes,
fichiers, images et export restent au Go, qui suit la discussion active.

Le Go reçoit LOKI_CHAT=rust et l'adresse de la façade (étape suivante :
lui remettre le trafic de chat du tunnel). Sans la variable, rien ne
change : tout part au Go comme avant.

ChatService gagne reset (fichiers effacés par le Go), la compaction
manuelle, le résultat complet d'un outil et le relais d'un événement ;
les critères changés par l'outil criteria sont journalisés pendant le
tour.

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

rust/loki-rs/src/proxy.rs

@@ -29,6 +29,7 @@ use tokio::net::TcpListener;
 
 use crate::api;
 use crate::auth::{HostEnv, INTERNAL_HEADER, InternalClient};
+use crate::chatapi;
 use crate::engine;
 use crate::oai;
 use crate::store::Store;
@@ -59,6 +60,9 @@ pub struct Config {
     pub host_env: HostEnv,
     /// `$LOKI_HOME` et service moteur, pour les routes portées.
     pub engine: engine::Paths,
+    /// Conversation tenue par la façade (`LOKI_CHAT=rust`) : ses routes sont
+    /// servies ici ; `None` : relayées au Go.
+    pub chat: Option<Arc<crate::chat::generate::ChatService>>,
 }
 
 struct Proxy {
@@ -85,6 +89,7 @@ pub async fn serve(
             internal: InternalClient::new(cfg.backend, cfg.internal_token),
             host_env: cfg.host_env,
             engine: cfg.engine,
+            chat: cfg.chat,
         },
     });
     tokio::pin!(shutdown);
@@ -142,6 +147,16 @@ impl Proxy {
         if api::handles(req.method(), path) {
             return api::serve(&self.ctx, req).await;
         }
+        if let Some(chat) = &self.ctx.chat {
+            if chatapi::handles(path) {
+                return chatapi::serve(&self.ctx, chat, req).await;
+            }
+            if chatapi::relays_delta(path) {
+                let (method, path) = (req.method().clone(), path.to_string());
+                let resp = self.forward(req).await;
+                return chatapi::after_forward(chat, &method, &path, resp).await;
+            }
+        }
         self.forward(req).await
     }