Fix build-server workflow and Rust server compile

Author: Copilot

.github/workflows/ci-cd.yml

@@ -8,7 +8,8 @@ on:
 
 env:
   CARGO_TERM_COLOR: always
-  RUST_VERSION: 1.75
+  RUST_VERSION: 1.85
+  CARGO_BUILD_JOBS: 1
 
 jobs:
   # Build and test Rust server

mohawk-server/src/api.rs

@@ -11,7 +11,7 @@ use axum::{
 use futures::StreamExt;
 use serde_json::json;
 use tower_http::cors::{Any, CorsLayer};
-use tracing::{info, error};
+use tracing::{error, info};
 
 use crate::engine::InferenceEngine;
 use crate::error::MohawkError;
@@ -26,32 +26,27 @@ pub struct AppState {
 /// Create the API router with all endpoints
 pub fn create_router(engine: InferenceEngine) -> Router {
     let state = AppState { engine };
-    
+
     // Configure CORS for GUI access
     let cors = CorsLayer::new()
         .allow_origin(Any)
         .allow_methods(Any)
         .allow_headers(Any);
-    
+
     Router::new()
         // Health & metrics
         .route("/health", get(health_check))
         .route("/metrics", get(get_metrics))
-        
         // Model management (OpenAI compatible)
         .route("/v1/models", get(list_models))
         .route("/v1/models/:model_id", get(get_model))
-        
         // Model loading/unloading (Mohawk extension)
         .route("/api/models/load", post(load_model))
         .route("/api/models/unload", post(unload_model))
-        
         // Chat completions (OpenAI compatible)
         .route("/v1/chat/completions", post(chat_completions))
-        
         // Legacy completions
         .route("/v1/completions", post(completions))
-        
         .layer(cors)
         .with_state(state)
 }
@@ -65,7 +60,7 @@ async fn health_check(State(state): State<AppState>) -> Json<HealthResponse> {
 /// Metrics endpoint (Prometheus format)
 async fn get_metrics(State(state): State<AppState>) -> impl IntoResponse {
     let stats = state.engine.get_stats().await;
-    
+
     let metrics = format!(
         r#"# HELP mohawk_uptime_seconds Server uptime in seconds
 # TYPE mohawk_uptime_seconds counter
@@ -79,18 +74,16 @@ mohawk_requests_total {}
 # TYPE mohawk_models_loaded gauge
 mohawk_models_loaded {}
 "#,
-        stats.uptime_secs,
-        stats.requests_total,
-        stats.models_loaded
+        stats.uptime_secs, stats.requests_total, stats.models_loaded
     );
-    
+
     (StatusCode::OK, metrics)
 }
 
 /// List available models (OpenAI compatible)
 async fn list_models(State(state): State<AppState>) -> Json<ModelListResponse> {
     let models = state.engine.list_models().await;
-    
+
     Json(ModelListResponse {
         object: "list".to_string(),
         data: models,
@@ -103,11 +96,12 @@ async fn get_model(
     axum::extract::Path(model_id): axum::extract::Path<String>,
 ) -> Result<Json<ModelInfo>, MohawkError> {
     let models = state.engine.list_models().await;
-    
-    let model = models.into_iter()
+
+    let model = models
+        .into_iter()
         .find(|m| m.id == model_id)
-        .ok_or_else(|| MohawkError::ModelNotFound(model_id))?;
-    
+        .ok_or(MohawkError::ModelNotFound(model_id))?;
+
     Ok(Json(model))
 }
 
@@ -120,15 +114,18 @@ async fn load_model(
         .as_str()
         .ok_or_else(|| MohawkError::InvalidRequest("model_id required".to_string()))?
         .to_string();
-    
+
     state.engine.load_model(&model_id).await?;
-    
+
     info!("Model loaded: {}", model_id);
-    Ok((StatusCode::OK, Json(json!({
-        "success": true,
-        "model_id": model_id,
-        "status": "loaded"
-    }))))
+    Ok((
+        StatusCode::OK,
+        Json(json!({
+            "success": true,
+            "model_id": model_id,
+            "status": "loaded"
+        })),
+    ))
 }
 
 /// Unload a model from memory
@@ -140,15 +137,18 @@ async fn unload_model(
         .as_str()
         .ok_or_else(|| MohawkError::InvalidRequest("model_id required".to_string()))?
         .to_string();
-    
+
     state.engine.unload_model(&model_id).await?;
-    
+
     info!("Model unloaded: {}", model_id);
-    Ok((StatusCode::OK, Json(json!({
-        "success": true,
-        "model_id": model_id,
-        "status": "unloaded"
-    }))))
+    Ok((
+        StatusCode::OK,
+        Json(json!({
+            "success": true,
+            "model_id": model_id,
+            "status": "unloaded"
+        })),
+    ))
 }
 
 /// Chat completions endpoint (OpenAI compatible)
@@ -159,27 +159,24 @@ async fn chat_completions(
     if request.stream {
         // Streaming response
         let stream = state.engine.generate_stream(request).await?;
-        
-        let stream_body = axum::body::Body::from_stream(
-            stream.map(|result| {
-                match result {
-                    Ok(token) => {
-                        let json = serde_json::to_string(&token).unwrap();
-                        Ok::<_, MohawkError>(format!("data: {}\n\n", json))
-                    }
-                    Err(e) => {
-                        error!("Stream error: {}", e);
-                        Ok("data: [DONE]\n\n".to_string())
-                    }
-                }
-            })
-        );
-        
+
+        let stream_body = axum::body::Body::from_stream(stream.map(|result| match result {
+            Ok(token) => {
+                let json = serde_json::to_string(&token).unwrap();
+                Ok::<_, MohawkError>(format!("data: {}\n\n", json))
+            }
+            Err(e) => {
+                error!("Stream error: {}", e);
+                Ok("data: [DONE]\n\n".to_string())
+            }
+        }));
+
         Ok((
             StatusCode::OK,
             [("Content-Type", "text/event-stream")],
             stream_body,
-        ).into_response())
+        )
+            .into_response())
     } else {
         // Non-streaming response
         let response = state.engine.generate(request).await?;
@@ -193,23 +190,26 @@ async fn completions(
     Json(payload): Json<serde_json::Value>,
 ) -> Result<impl IntoResponse, MohawkError> {
     // Convert legacy format to chat format
-    let prompt = payload["prompt"]
-        .as_str()
-        .unwrap_or("")
-        .to_string();
-    
+    let prompt = payload["prompt"].as_str().unwrap_or("").to_string();
+
     let messages = vec![Message {
         role: "user".to_string(),
         content: prompt,
     }];
-    
+
     let request = InferenceRequest {
         messages,
         model: payload["model"].as_str().map(|s| s.to_string()),
         temperature: payload["temperature"].as_f64().map(|f| f as f32),
         top_p: payload["top_p"].as_f64().map(|f| f as f32),
-        top_k: payload.get("top_k").and_then(|v| v.as_i64()).map(|i| i as i32),
-        max_tokens: payload.get("max_tokens").and_then(|v| v.as_i64()).map(|i| i as i32),
+        top_k: payload
+            .get("top_k")
+            .and_then(|v| v.as_i64())
+            .map(|i| i as i32),
+        max_tokens: payload
+            .get("max_tokens")
+            .and_then(|v| v.as_i64())
+            .map(|i| i as i32),
         stream: payload["stream"].as_bool().unwrap_or(false),
         stop: payload.get("stop").and_then(|v| v.as_array()).map(|arr| {
             arr.iter()
@@ -218,7 +218,7 @@ async fn completions(
         }),
         system_prompt: None,
     };
-    
+
     let response = state.engine.generate(request).await?;
     Ok(Json(response))
 }