MoA: mesh answers improve as capable nodes join

crates/mesh-llm-host-runtime/src/models/gguf.rs

@@ -1 +1,3 @@
-pub use model_artifact::gguf::{GgufCompactMeta, GgufKvCacheQuant, scan_gguf_compact_meta};
+pub use model_artifact::gguf::{
+    GgufCompactMeta, GgufKvCacheQuant, scan_gguf_compact_meta, scan_gguf_total_parameters,
+};

crates/mesh-llm-host-runtime/src/models/profile.rs

@@ -24,11 +24,16 @@ pub(crate) fn served_model_metadata_for_path(
                 .parameter_size
                 .clone()
                 .or_else(|| parameter_size_from_text(model_name));
-            let parameter_count_b = parameter_count_b_from_text(&format!(
-                "{} {}",
-                model_name,
-                meta.parameter_size.as_deref().unwrap_or("")
-            ));
+            // Authoritative size: sum the GGUF tensor element counts. This is
+            // the ONLY source — no name-based fallback. If a served model
+            // cannot be summed from its GGUF, it advertises no size and MoA
+            // tiering treats it as the lowest-param (weakest) model rather than
+            // guessing from a brittle name label (per i386 review).
+            let parameter_count_b = path
+                .exists()
+                .then(|| crate::models::gguf::scan_gguf_total_parameters(path))
+                .flatten()
+                .map(|total| total as f64 / 1e9);
             let kv_head_count = meta.effective_kv_head_count();
             crate::mesh::ServedModelMetadata {
                 architecture: non_empty(meta.architecture),
@@ -51,7 +56,10 @@ pub(crate) fn served_model_metadata_for_path(
         }
         None => crate::mesh::ServedModelMetadata {
             parameter_size: parameter_size_from_text(model_name),
-            parameter_count_b: parameter_count_b_from_text(model_name),
+            // No GGUF to sum -> no authoritative size. Advertise none rather
+            // than a name-guessed count (per i386 review); MoA treats a
+            // sizeless model as the weakest.
+            parameter_count_b: None,
             quant: quant_from_text(model_name),
             ..Default::default()
         },
@@ -99,50 +107,9 @@ fn parameter_size_from_text(text: &str) -> Option<String> {
         })
 }
 
-fn parameter_count_b_from_text(text: &str) -> Option<f64> {
-    static MULTIPLIED_RE: LazyLock<Regex> =
-        LazyLock::new(|| Regex::new(r"(?i)(\d+(?:\.\d+)?)x(\d+(?:\.\d+)?)([bm])").unwrap());
-    static SIMPLE_RE: LazyLock<Regex> =
-        LazyLock::new(|| Regex::new(r"(?i)(\d+(?:\.\d+)?)([bm])").unwrap());
-
-    let mut best: Option<f64> = None;
-    for captures in MULTIPLIED_RE.captures_iter(text) {
-        let Some(left) = captures.get(1).and_then(|m| m.as_str().parse::<f64>().ok()) else {
-            continue;
-        };
-        let Some(right) = captures.get(2).and_then(|m| m.as_str().parse::<f64>().ok()) else {
-            continue;
-        };
-        let Some(unit) = captures.get(3).map(|m| m.as_str().to_ascii_lowercase()) else {
-            continue;
-        };
-        let value = match unit.as_str() {
-            "b" => left * right,
-            "m" => (left * right) / 1000.0,
-            _ => continue,
-        };
-        best = Some(best.map_or(value, |current| current.max(value)));
-    }
-    for captures in SIMPLE_RE.captures_iter(text) {
-        let Some(count) = captures.get(1).and_then(|m| m.as_str().parse::<f64>().ok()) else {
-            continue;
-        };
-        let Some(unit) = captures.get(2).map(|m| m.as_str().to_ascii_lowercase()) else {
-            continue;
-        };
-        let value = match unit.as_str() {
-            "b" => count,
-            "m" => count / 1000.0,
-            _ => continue,
-        };
-        best = Some(best.map_or(value, |current| current.max(value)));
-    }
-    best
-}
-
 #[cfg(test)]
 mod tests {
-    use super::{parameter_count_b_from_text, parameter_size_from_text};
+    use super::parameter_size_from_text;
 
     #[test]
     fn extracts_parameter_size_labels() {
@@ -155,11 +122,4 @@ mod tests {
             Some("8x7B")
         );
     }
-
-    #[test]
-    fn extracts_total_parameter_count_b() {
-        assert_eq!(parameter_count_b_from_text("Qwen3-32B-Q4_K_M"), Some(32.0));
-        assert_eq!(parameter_count_b_from_text("mixtral-8x7b"), Some(56.0));
-        assert_eq!(parameter_count_b_from_text("235B-A22B"), Some(235.0));
-    }
 }

crates/mesh-llm-host-runtime/src/network/openai/ingress.rs

@@ -743,6 +743,14 @@ enum MoaInterceptResult {
     /// Not an MoA request — caller should continue with normal routing,
     /// reusing the returned stream.
     NotMoa(tokio::net::TcpStream),
+    /// MoA could not form a committee but degraded `model=mesh` to a real
+    /// single model (already rewritten on the request). Caller routes it
+    /// normally, but must use this model rather than the stale
+    /// `decision.effective_model` (still "mesh").
+    Degraded {
+        stream: tokio::net::TcpStream,
+        model: Option<String>,
+    },
 }
 
 /// Dispatch to the MoA gateway when `model == "mesh"`. Self-gates on the
@@ -756,24 +764,34 @@ async fn try_handle_moa_intercept(
     if decision.effective_model.as_deref() != Some(moa::VIRTUAL_MODEL_NAME) {
         return MoaInterceptResult::NotMoa(tcp_stream);
     }
-    // `try_handle_moa` self-gates on the model name and consumes the
-    // stream when it accepts. The outer gate above guarantees the gate
-    // matches, so the inner call always returns `None` here — the stream
-    // is gone, either with the MoA response, a 503, or a 400. Discard
-    // the return value explicitly. The previous shape kept an
-    // `if let Some(_) = … { tracing::error!(...) }` branch that could
-    // never fire and made the control flow confusing to read.
-    let _ = crate::network::openai::moa_gateway::try_handle_moa(
+    // `try_handle_moa` self-gates on the model name. It consumes the stream and
+    // returns `None` when it owns the response (a MoA turn, a 400, or — no
+    // model at all — a 503). But when it cannot form a committee yet still has
+    // a model to serve, it degrades: it rewrites `model=mesh` to a real model
+    // (on `request`) and hands the stream *back* as `Some`, so a lone node
+    // answers as an ordinary single-model request instead of erroring. In that
+    // case the pre-computed `decision.effective_model` is stale ("mesh"), so we
+    // carry the degraded model name out for the caller to route on.
+    match crate::network::openai::moa_gateway::try_handle_moa(
         ctx.route.node,
         tcp_stream,
         request,
         decision.effective_model.as_deref(),
         Some(ctx.route.targets),
         decision.required_tokens,
     )
-    .await;
-    proxy::release_request_objects(ctx.route.node, &request.request_object_request_ids).await;
-    MoaInterceptResult::Handled
+    .await
+    {
+        Some(stream) => MoaInterceptResult::Degraded {
+            stream,
+            model: request.model_name.clone(),
+        },
+        None => {
+            proxy::release_request_objects(ctx.route.node, &request.request_object_request_ids)
+                .await;
+            MoaInterceptResult::Handled
+        }
+    }
 }
 
 async fn handle_buffered_api_request(
@@ -817,14 +835,25 @@ async fn handle_buffered_api_request(
         }
     };
 
+    // Effective model for downstream routing. Normally the pre-computed
+    // decision, but a degraded MoA turn overrides it with the single model it
+    // fell back to (the decision still says "mesh").
+    let mut routing_model = decision.effective_model.clone();
     let tcp_stream = match try_handle_moa_intercept(tcp_stream, &mut request, &ctx, &decision).await
     {
         MoaInterceptResult::Handled => return,
         MoaInterceptResult::NotMoa(stream) => stream,
+        MoaInterceptResult::Degraded { stream, model } => {
+            routing_model = model;
+            stream
+        }
     };
 
     let mut tcp_stream = tcp_stream;
-    if try_pipeline_route(&mut tcp_stream, &mut request, &ctx.route, &decision).await {
+    // A degraded turn is a plain single-model request; skip the pipeline
+    // classifier (computed against "mesh") and route it directly.
+    let degraded = routing_model != decision.effective_model;
+    if !degraded && try_pipeline_route(&mut tcp_stream, &mut request, &ctx.route, &decision).await {
         proxy::release_request_objects(ctx.route.node, &request.request_object_request_ids).await;
         return;
     }
@@ -833,7 +862,7 @@ async fn handle_buffered_api_request(
         tcp_stream,
         &mut request,
         &ctx.route,
-        decision.effective_model.as_deref(),
+        routing_model.as_deref(),
         decision.required_tokens,
     )
     .await;

crates/mesh-llm-host-runtime/src/network/openai/moa_gateway/mod.rs

@@ -20,6 +20,57 @@ use tokio::net::TcpStream;
 
 pub use self::workers::build_moa_config;
 
+/// Fall back to serving a single real model when MoA cannot form a committee.
+///
+/// Picks any model advertised in the mesh (local or peer), rewrites the
+/// request's `model` from the virtual `"mesh"` name to it, and hands the stream
+/// back so the caller routes it as an ordinary single-model request. Returns
+/// `None` (503) only when the node genuinely has no model at all.
+async fn degrade_to_single_model(
+    node: &mesh::Node,
+    targets: Option<&election::ModelTargets>,
+    tcp_stream: TcpStream,
+    request: &mut proxy::BufferedHttpRequest,
+) -> Option<TcpStream> {
+    // Prefer the same source `/v1/models` and routing use — the local
+    // targets table (`callable_models`) — since `models_being_served()` can be
+    // empty at request time on a fresh serve node. Fall back to the gossiped
+    // served set for a pure client node that has no local targets.
+    // Try each source /v1/models draws from, cheapest-first: the local targets
+    // table (`callable_models`), the gossiped served set, then the node's own
+    // `serving_models` — the last is what a fresh serve node populates first
+    // (the others can lag at request time).
+    let mut candidates = targets
+        .map(super::ingress::callable_models)
+        .unwrap_or_default();
+    if candidates.is_empty() {
+        candidates = node.models_being_served().await;
+    }
+    if candidates.is_empty() {
+        candidates = node.serving_models().await;
+    }
+    let Some(target) = candidates
+        .into_iter()
+        .find(|m| m != moa::VIRTUAL_MODEL_NAME)
+    else {
+        let _ = proxy::send_503(tcp_stream, "no models available in the mesh").await;
+        return None;
+    };
+
+    tracing::info!("MoA: <2 workers, degrading model=mesh to single model {target}");
+
+    // Rewrite every surface the downstream router reads. The forwarded request
+    // is driven by `request.raw` (the raw HTTP bytes), so `rewrite_model_field`
+    // patches raw + body + Content-Length together — rewriting only
+    // `model_name`/`body_json` left `raw` saying "mesh", so the embedded
+    // frontend still saw the virtual model and 404'd.
+    proxy::rewrite_model_field(request, &target);
+    request.model_name = Some(target);
+
+    // Hand the stream back: the caller falls through to normal routing.
+    Some(tcp_stream)
+}
+
 /// Detect `model: "mesh"`, build a mesh-wide MoA config, run the turn,
 /// and write the HTTP response (JSON or SSE) directly to the stream.
 ///
@@ -52,11 +103,28 @@ pub async fn try_handle_moa(
         return None;
     };
 
+    // Contract check: `messages` must be a present, non-empty array. Without
+    // this a request like `{"model":"mesh"}` or a string `messages` field fell
+    // through to the workers, which fabricated a 200 answer from nothing
+    // (homelab API-1 defect). Reject before any model call.
+    match body_json.get("messages") {
+        Some(serde_json::Value::Array(msgs)) if !msgs.is_empty() => {}
+        _ => {
+            let _ = proxy::send_400(tcp_stream, "MoA requires a non-empty `messages` array").await;
+            return None;
+        }
+    }
+
     let enable_thinking = effective_enable_thinking_for_moa(&body_json);
 
     let Some(mut config) = build_moa_config(node, targets, required_tokens).await else {
-        let _ = proxy::send_503(tcp_stream, "MoA requires ≥2 models available in the mesh").await;
-        return None;
+        // Graceful degradation: MoA needs ≥2 workers, but a lone node (or a
+        // mesh with a single model) should still answer a `model=mesh`
+        // request rather than 503. Rewrite the virtual model to a real served
+        // model and fall through to normal single-model routing by handing the
+        // stream back. `mesh` thus works everywhere: passthrough on one node,
+        // committee once a second worker joins.
+        return degrade_to_single_model(node, targets, tcp_stream, request).await;
     };
     config.enable_thinking = enable_thinking;
 
@@ -65,6 +133,7 @@ pub async fn try_handle_moa(
 }
 
 pub(in crate::network::openai) mod context_selection;
+mod pool;
 mod progress;
 mod streaming;
 mod workers;