Lot 36 : appels d'outils MCP du tour de la façade par son pool

Quand la façade tient les serveurs MCP (LOKI_MCP=rust), un appel mcp__*
d'un de ses tours partait au Go (/internal/v1/tool/exec), qui le renvoyait
aussitôt à la façade (/internal/facade/v1/mcp/call) : deux allers-retours
pour revenir au même pool. Le Go n'ajoute rien au résultat d'un outil MCP.

ChatShared porte désormais le pool (le même que celui des routes, créé une
fois) ; GoTurnHost::exec_tool l'appelle directement — même résultat que la
route interne, reconnexion comprise. Une reconnexion annonce la version du
Go (/internal/v1/auth), lue une fois et retenue. Sans pool tenu, rien ne
change. Le Go garde la route interne pour les tours qu'il exécute encore.

Test : un tour de la façade contre un faux serveur MCP stdio — rien par le
Go, résultats tels que le modèle les reçoit, erreur après reconnexion,
version du Go annoncée.

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

rust/loki-rs/src/chat/generate.rs

@@ -1303,6 +1303,8 @@ impl ChatShared {
             patterns: super::stream::RetryPatterns::builtin(),
             tpl: std::sync::Arc::new(super::tplprobe::TplProbe::new()),
             prewarm: Default::default(),
+            mcp: None,
+            go_version: Default::default(),
         }
     }
 }

rust/loki-rs/src/chat/host.rs

@@ -3,7 +3,8 @@
 //! - envoi au moteur par [`EngineHttp`] (clé de CET endpoint), pannes
 //!   classées et formulées comme `friendlyLLMError` ;
 //! - outils fichiers et shell exécutés ici ([`crate::tools`], état partagé
-//!   tenu par le Go) ; les autres par le Go (`/internal/v1/tool/exec`), avec
+//!   tenu par le Go), outils MCP par le pool de la façade quand elle le tient
+//!   (lot 36) ; les autres par le Go (`/internal/v1/tool/exec`), avec
 //!   ce qu'il tire du résultat (capture de la bulle, aperçu du navigateur,
 //!   image relayée) ;
 //! - résultats complets (« voir plus ») confiés à l'écrivain des discussions ;
@@ -330,6 +331,32 @@ pub struct ChatShared {
     pub tpl: Arc<super::tplprobe::TplProbe>,
     /// Préchauffage (PREWARM) : celui en vol, capacités des discussions.
     pub prewarm: super::prewarm::Prewarm,
+    /// Le pool MCP, quand la façade le tient (LOKI_MCP=rust) : les appels
+    /// `mcp__*` du tour y vont directement (lot 36).
+    pub mcp: Option<Arc<crate::mcp::Mcp>>,
+    /// La version du Go, annoncée aux serveurs MCP à une reconnexion ; lue
+    /// une fois.
+    pub go_version: tokio::sync::OnceCell<String>,
+}
+
+impl ChatShared {
+    /// [`Self::go_version`] : `/internal/v1/auth`, retenue une fois lue.
+    pub async fn go_version(&self) -> String {
+        if let Some(v) = self.go_version.get() {
+            return v.clone();
+        }
+        let v = self
+            .store
+            .internal_json(hyper::Method::GET, "/internal/v1/auth", None)
+            .await
+            .ok()
+            .and_then(|v| v.get("version").and_then(Value::as_str).map(str::to_string))
+            .unwrap_or_default();
+        if !v.is_empty() {
+            let _ = self.go_version.set(v.clone());
+        }
+        v
+    }
 }
 
 /// Ce que la compaction sait du tour.
@@ -615,6 +642,18 @@ impl TurnHost for GoTurnHost {
     }
 
     async fn exec_tool(&self, name: &str, args: &Map<String, Value>, label: &str) -> ToolOutcome {
+        // Outils MCP, quand la façade tient le pool : ce que ferait le Go
+        // (`mcpCall` → /internal/facade/v1/mcp/call), sans ses deux
+        // allers-retours. Le Go n'en tire rien d'autre que le texte.
+        if crate::mcp::config::is_mcp_tool(name)
+            && let Some(mcp) = &self.shared.mcp
+        {
+            let version = self.shared.go_version().await;
+            return ToolOutcome {
+                result: mcp.call(&self.shared.store, name, args, &version).await,
+                ..Default::default()
+            };
+        }
         // Outils fichiers et shell : ici (lot 7), l'état partagé restant au Go.
         if crate::tools::is_local(name) {
             let st = crate::tools::GoToolState {

rust/loki-rs/src/main.rs

@@ -262,8 +262,11 @@ fn serve() -> ExitCode {
                     return ExitCode::FAILURE;
                 }
             };
+        // Un seul pool MCP : celui des routes, et celui des tours de la façade.
+        let mcp = mcp_rust
+            .then(|| std::sync::Arc::new(loki_rs::mcp::Mcp::new(engine_paths.home.clone())));
         let chat = if chat_rust {
-            match start_chat(backend, &token, &engine_paths.home).await {
+            match start_chat(backend, &token, &engine_paths.home, mcp.clone()).await {
                 Ok(c) => Some(c),
                 Err(e) => {
                     eprintln!("[loki-rs] conversation : {e}");
@@ -386,8 +389,7 @@ fn serve() -> ExitCode {
             settings: settings_rust,
             files,
             push: push_rust.then(|| std::sync::Arc::new(loki_rs::push::Push::new())),
-            mem: mem_rust
-                .then(|| std::sync::Arc::new(loki_rs::memory::Memory::new(mem_home.clone()))),
+            mem: mem_rust.then(|| std::sync::Arc::new(loki_rs::memory::Memory::new(mem_home))),
             presets: presets_rust,
             engine_ctl,
             system: system_rust.then(|| std::sync::Arc::new(loki_rs::system::System::new())),
@@ -399,7 +401,7 @@ fn serve() -> ExitCode {
             tasks,
             bench,
             tune,
-            mcp: mcp_rust.then(|| std::sync::Arc::new(loki_rs::mcp::Mcp::new(mem_home))),
+            mcp,
         };
         let res = proxy::serve(listener, cfg, shutdown_signal()).await;
         eprintln!("[loki-rs] arrêt demandé — arrêt du serveur Go");
@@ -510,6 +512,7 @@ async fn start_chat(
     backend: SocketAddr,
     token: &str,
     home: &std::path::Path,
+    mcp: Option<std::sync::Arc<loki_rs::mcp::Mcp>>,
 ) -> Result<std::sync::Arc<loki_rs::chat::generate::ChatService>, String> {
     use loki_rs::chat::{conv::Conversation, generate::ChatService, host::ChatShared, sessions};
     let store = loki_rs::store::Store::new(backend, token.to_string());
@@ -521,6 +524,7 @@ async fn start_chat(
     s.load().await?;
     let mut shared = ChatShared::for_sessions(&s, store.clone(), home.join("chatimg"));
     shared.patterns = loki_rs::chat::generate::retry_patterns(&store).await;
+    shared.mcp = mcp;
     eprintln!("[loki-rs] conversation tenue par la façade (LOKI_CHAT=go pour la rendre au Go)");
     Ok(ChatService::new(
         std::sync::Arc::new(s),