run cargo fmt

.github/workflows/ci.yml

@@ -44,7 +44,7 @@ jobs:
 
       - name: Clippy
         shell: bash
-        run: cargo clippy --all-targets
+        run: cargo clippy --all
 
       - name: Tests
         shell: bash

crates/chat-ui/src/app.rs

@@ -257,7 +257,8 @@ pub fn send_chat_completion_stream(
                                 break;
                             }
 
-                            let value = js_sys::Reflect::get(&result, &JsValue::from_str("value")).unwrap();
+                            let value =
+                                js_sys::Reflect::get(&result, &JsValue::from_str("value")).unwrap();
                             let array = js_sys::Uint8Array::new(&value);
                             let mut bytes = vec![0; array.length() as usize];
                             array.copy_to(&mut bytes);
@@ -279,7 +280,9 @@ pub fn send_chat_completion_stream(
                                         }
 
                                         // Parse JSON chunk
-                                        if let Ok(chunk) = serde_json::from_str::<StreamChatResponse>(data) {
+                                        if let Ok(chunk) =
+                                            serde_json::from_str::<StreamChatResponse>(data)
+                                        {
                                             if let Some(choice) = chunk.choices.first() {
                                                 if let Some(content) = &choice.delta.content {
                                                     on_chunk(content.clone());

crates/embeddings-engine/src/lib.rs

@@ -1,5 +1,10 @@
 use async_openai::types::{CreateEmbeddingRequest, EmbeddingInput};
-use axum::{Json, Router, response::Json as ResponseJson, routing::{get, post}, http::StatusCode};
+use axum::{
+    Json, Router,
+    http::StatusCode,
+    response::Json as ResponseJson,
+    routing::{get, post},
+};
 use fastembed::{EmbeddingModel, InitOptions, TextEmbedding};
 use once_cell::sync::Lazy;
 use serde::Serialize;
@@ -9,9 +14,8 @@ use tower_http::trace::TraceLayer;
 use tracing;
 
 // Cache for multiple embedding models
-static MODEL_CACHE: Lazy<RwLock<HashMap<EmbeddingModel, Arc<TextEmbedding>>>> = Lazy::new(|| {
+static MODEL_CACHE: Lazy<RwLock<HashMap<EmbeddingModel, Arc<TextEmbedding>>>> =
-    RwLock::new(HashMap::new())
+    Lazy::new(|| RwLock::new(HashMap::new()));
-});
 
 #[derive(Serialize)]
 pub struct ModelInfo {
@@ -32,10 +36,18 @@ pub struct ModelsResponse {
 fn parse_embedding_model(model_name: &str) -> Result<EmbeddingModel, String> {
     match model_name {
         // Sentence Transformers models
-        "sentence-transformers/all-MiniLM-L6-v2" | "all-minilm-l6-v2" => Ok(EmbeddingModel::AllMiniLML6V2),
+        "sentence-transformers/all-MiniLM-L6-v2" | "all-minilm-l6-v2" => {
-        "sentence-transformers/all-MiniLM-L6-v2-q" | "all-minilm-l6-v2-q" => Ok(EmbeddingModel::AllMiniLML6V2Q),
+            Ok(EmbeddingModel::AllMiniLML6V2)
-        "sentence-transformers/all-MiniLM-L12-v2" | "all-minilm-l12-v2" => Ok(EmbeddingModel::AllMiniLML12V2),
+        }
-        "sentence-transformers/all-MiniLM-L12-v2-q" | "all-minilm-l12-v2-q" => Ok(EmbeddingModel::AllMiniLML12V2Q),
+        "sentence-transformers/all-MiniLM-L6-v2-q" | "all-minilm-l6-v2-q" => {
+            Ok(EmbeddingModel::AllMiniLML6V2Q)
+        }
+        "sentence-transformers/all-MiniLM-L12-v2" | "all-minilm-l12-v2" => {
+            Ok(EmbeddingModel::AllMiniLML12V2)
+        }
+        "sentence-transformers/all-MiniLM-L12-v2-q" | "all-minilm-l12-v2-q" => {
+            Ok(EmbeddingModel::AllMiniLML12V2Q)
+        }
 
         // BGE models
         "BAAI/bge-base-en-v1.5" | "bge-base-en-v1.5" => Ok(EmbeddingModel::BGEBaseENV15),
@@ -48,38 +60,65 @@ fn parse_embedding_model(model_name: &str) -> Result<EmbeddingModel, String> {
         "BAAI/bge-large-zh-v1.5" | "bge-large-zh-v1.5" => Ok(EmbeddingModel::BGELargeZHV15),
 
         // Nomic models
-        "nomic-ai/nomic-embed-text-v1" | "nomic-embed-text-v1" => Ok(EmbeddingModel::NomicEmbedTextV1),
+        "nomic-ai/nomic-embed-text-v1" | "nomic-embed-text-v1" => {
-        "nomic-ai/nomic-embed-text-v1.5" | "nomic-embed-text-v1.5" | "nomic-text-embed" => Ok(EmbeddingModel::NomicEmbedTextV15),
+            Ok(EmbeddingModel::NomicEmbedTextV1)
-        "nomic-ai/nomic-embed-text-v1.5-q" | "nomic-embed-text-v1.5-q" => Ok(EmbeddingModel::NomicEmbedTextV15Q),
+        }
+        "nomic-ai/nomic-embed-text-v1.5" | "nomic-embed-text-v1.5" | "nomic-text-embed" => {
+            Ok(EmbeddingModel::NomicEmbedTextV15)
+        }
+        "nomic-ai/nomic-embed-text-v1.5-q" | "nomic-embed-text-v1.5-q" => {
+            Ok(EmbeddingModel::NomicEmbedTextV15Q)
+        }
 
         // Paraphrase models
-        "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2" | "paraphrase-multilingual-minilm-l12-v2" => Ok(EmbeddingModel::ParaphraseMLMiniLML12V2),
+        "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"
-        "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2-q" | "paraphrase-multilingual-minilm-l12-v2-q" => Ok(EmbeddingModel::ParaphraseMLMiniLML12V2Q),
+        | "paraphrase-multilingual-minilm-l12-v2" => Ok(EmbeddingModel::ParaphraseMLMiniLML12V2),
-        "sentence-transformers/paraphrase-multilingual-mpnet-base-v2" | "paraphrase-multilingual-mpnet-base-v2" => Ok(EmbeddingModel::ParaphraseMLMpnetBaseV2),
+        "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2-q"
+        | "paraphrase-multilingual-minilm-l12-v2-q" => Ok(EmbeddingModel::ParaphraseMLMiniLML12V2Q),
+        "sentence-transformers/paraphrase-multilingual-mpnet-base-v2"
+        | "paraphrase-multilingual-mpnet-base-v2" => Ok(EmbeddingModel::ParaphraseMLMpnetBaseV2),
 
         // ModernBert
-        "lightonai/modernbert-embed-large" | "modernbert-embed-large" => Ok(EmbeddingModel::ModernBertEmbedLarge),
+        "lightonai/modernbert-embed-large" | "modernbert-embed-large" => {
+            Ok(EmbeddingModel::ModernBertEmbedLarge)
+        }
 
         // Multilingual E5 models
-        "intfloat/multilingual-e5-small" | "multilingual-e5-small" => Ok(EmbeddingModel::MultilingualE5Small),
+        "intfloat/multilingual-e5-small" | "multilingual-e5-small" => {
-        "intfloat/multilingual-e5-base" | "multilingual-e5-base" => Ok(EmbeddingModel::MultilingualE5Base),
+            Ok(EmbeddingModel::MultilingualE5Small)
-        "intfloat/multilingual-e5-large" | "multilingual-e5-large" => Ok(EmbeddingModel::MultilingualE5Large),
+        }
+        "intfloat/multilingual-e5-base" | "multilingual-e5-base" => {
+            Ok(EmbeddingModel::MultilingualE5Base)
+        }
+        "intfloat/multilingual-e5-large" | "multilingual-e5-large" => {
+            Ok(EmbeddingModel::MultilingualE5Large)
+        }
 
         // Mixedbread models
-        "mixedbread-ai/mxbai-embed-large-v1" | "mxbai-embed-large-v1" => Ok(EmbeddingModel::MxbaiEmbedLargeV1),
+        "mixedbread-ai/mxbai-embed-large-v1" | "mxbai-embed-large-v1" => {
-        "mixedbread-ai/mxbai-embed-large-v1-q" | "mxbai-embed-large-v1-q" => Ok(EmbeddingModel::MxbaiEmbedLargeV1Q),
+            Ok(EmbeddingModel::MxbaiEmbedLargeV1)
+        }
+        "mixedbread-ai/mxbai-embed-large-v1-q" | "mxbai-embed-large-v1-q" => {
+            Ok(EmbeddingModel::MxbaiEmbedLargeV1Q)
+        }
 
         // GTE models
         "Alibaba-NLP/gte-base-en-v1.5" | "gte-base-en-v1.5" => Ok(EmbeddingModel::GTEBaseENV15),
-        "Alibaba-NLP/gte-base-en-v1.5-q" | "gte-base-en-v1.5-q" => Ok(EmbeddingModel::GTEBaseENV15Q),
+        "Alibaba-NLP/gte-base-en-v1.5-q" | "gte-base-en-v1.5-q" => {
+            Ok(EmbeddingModel::GTEBaseENV15Q)
+        }
         "Alibaba-NLP/gte-large-en-v1.5" | "gte-large-en-v1.5" => Ok(EmbeddingModel::GTELargeENV15),
-        "Alibaba-NLP/gte-large-en-v1.5-q" | "gte-large-en-v1.5-q" => Ok(EmbeddingModel::GTELargeENV15Q),
+        "Alibaba-NLP/gte-large-en-v1.5-q" | "gte-large-en-v1.5-q" => {
+            Ok(EmbeddingModel::GTELargeENV15Q)
+        }
 
         // CLIP model
         "Qdrant/clip-ViT-B-32-text" | "clip-vit-b-32" => Ok(EmbeddingModel::ClipVitB32),
 
         // Jina model
-        "jinaai/jina-embeddings-v2-base-code" | "jina-embeddings-v2-base-code" => Ok(EmbeddingModel::JinaEmbeddingsV2BaseCode),
+        "jinaai/jina-embeddings-v2-base-code" | "jina-embeddings-v2-base-code" => {
+            Ok(EmbeddingModel::JinaEmbeddingsV2BaseCode)
+        }
 
         _ => Err(format!("Unsupported embedding model: {}", model_name)),
     }
@@ -95,7 +134,9 @@ fn get_model_dimensions(model: &EmbeddingModel) -> usize {
         EmbeddingModel::BGESmallENV15 | EmbeddingModel::BGESmallENV15Q => 384,
         EmbeddingModel::BGESmallZHV15 => 512,
         EmbeddingModel::BGELargeZHV15 => 1024,
-        EmbeddingModel::NomicEmbedTextV1 | EmbeddingModel::NomicEmbedTextV15 | EmbeddingModel::NomicEmbedTextV15Q => 768,
+        EmbeddingModel::NomicEmbedTextV1
+        | EmbeddingModel::NomicEmbedTextV15
+        | EmbeddingModel::NomicEmbedTextV15Q => 768,
         EmbeddingModel::ParaphraseMLMiniLML12V2 | EmbeddingModel::ParaphraseMLMiniLML12V2Q => 384,
         EmbeddingModel::ParaphraseMLMpnetBaseV2 => 768,
         EmbeddingModel::ModernBertEmbedLarge => 1024,
@@ -114,7 +155,9 @@ fn get_model_dimensions(model: &EmbeddingModel) -> usize {
 fn get_or_create_model(embedding_model: EmbeddingModel) -> Result<Arc<TextEmbedding>, String> {
     // First try to get from cache (read lock)
     {
-        let cache = MODEL_CACHE.read().map_err(|e| format!("Failed to acquire read lock: {}", e))?;
+        let cache = MODEL_CACHE
+            .read()
+            .map_err(|e| format!("Failed to acquire read lock: {}", e))?;
         if let Some(model) = cache.get(&embedding_model) {
             tracing::debug!("Using cached model: {:?}", embedding_model);
             return Ok(Arc::clone(model));
@@ -122,7 +165,9 @@ fn get_or_create_model(embedding_model: EmbeddingModel) -> Result<Arc<TextEmbedd
     }
 
     // Model not in cache, create it (write lock)
-    let mut cache = MODEL_CACHE.write().map_err(|e| format!("Failed to acquire write lock: {}", e))?;
+    let mut cache = MODEL_CACHE
+        .write()
+        .map_err(|e| format!("Failed to acquire write lock: {}", e))?;
 
     // Double-check after acquiring write lock
     if let Some(model) = cache.get(&embedding_model) {
@@ -171,7 +216,10 @@ pub async fn embeddings_create(
         Ok(model) => model,
         Err(e) => {
             tracing::error!("Failed to get/create model: {}", e);
-            return Err((StatusCode::INTERNAL_SERVER_ERROR, format!("Model initialization failed: {}", e)));
+            return Err((
+                StatusCode::INTERNAL_SERVER_ERROR,
+                format!("Model initialization failed: {}", e),
+            ));
         }
     };
 
@@ -205,12 +253,13 @@ pub async fn embeddings_create(
     // Phase 3: Generate embeddings
     let embedding_start_time = std::time::Instant::now();
 
-    let embeddings = model
+    let embeddings = model.embed(texts_from_embedding_input, None).map_err(|e| {
-        .embed(texts_from_embedding_input, None)
+        tracing::error!("Failed to generate embeddings: {}", e);
-        .map_err(|e| {
+        (
-            tracing::error!("Failed to generate embeddings: {}", e);
+            StatusCode::INTERNAL_SERVER_ERROR,
-            (StatusCode::INTERNAL_SERVER_ERROR, format!("Embedding generation failed: {}", e))
+            format!("Embedding generation failed: {}", e),
-        })?;
+        )
+    })?;
 
     let embedding_generation_time = embedding_start_time.elapsed();
     tracing::info!(
@@ -455,7 +504,8 @@ pub async fn models_list() -> ResponseJson<ModelsResponse> {
             id: "nomic-ai/nomic-embed-text-v1.5-q".to_string(),
             object: "model".to_string(),
             owned_by: "nomic-ai".to_string(),
-            description: "Quantized v1.5 release of the 8192 context length english model".to_string(),
+            description: "Quantized v1.5 release of the 8192 context length english model"
+                .to_string(),
             dimensions: 768,
         },
         ModelInfo {
@@ -476,7 +526,8 @@ pub async fn models_list() -> ResponseJson<ModelsResponse> {
             id: "sentence-transformers/paraphrase-multilingual-mpnet-base-v2".to_string(),
             object: "model".to_string(),
             owned_by: "sentence-transformers".to_string(),
-            description: "Sentence-transformers model for tasks like clustering or semantic search".to_string(),
+            description: "Sentence-transformers model for tasks like clustering or semantic search"
+                .to_string(),
             dimensions: 768,
         },
         ModelInfo {

crates/embeddings-engine/src/main.rs

@@ -18,12 +18,10 @@ async fn embeddings_create(
 ) -> Result<ResponseJson<serde_json::Value>, axum::response::Response> {
     match embeddings_engine::embeddings_create(Json(payload)).await {
         Ok(response) => Ok(response),
-        Err((status_code, message)) => {
+        Err((status_code, message)) => Err(axum::response::Response::builder()
-            Err(axum::response::Response::builder()
+            .status(status_code)
-                .status(status_code)
+            .body(axum::body::Body::from(message))
-                .body(axum::body::Body::from(message))
+            .unwrap()),
-                .unwrap())
-        }
     }
 }
 

crates/inference-engine/src/model.rs

@@ -42,7 +42,11 @@ pub struct ModelMeta {
 }
 
 const fn m(id: &'static str, family: Family, instruct: bool) -> ModelMeta {
-    ModelMeta { id, family, instruct }
+    ModelMeta {
+        id,
+        family,
+        instruct,
+    }
 }
 
 #[derive(Clone, Debug, Copy, PartialEq, Eq, clap::ValueEnum)]

crates/inference-engine/src/server.rs

@@ -42,12 +42,12 @@ pub struct AppState {
     pub llama_config: Option<LlamaInferenceConfig>,
 }
 
-
 impl Default for AppState {
     fn default() -> Self {
         // Configure a default model to prevent 503 errors from the chat-ui
         // This can be overridden by environment variables if needed
-        let default_model_id = std::env::var("DEFAULT_MODEL").unwrap_or_else(|_| "gemma-3-1b-it".to_string());
+        let default_model_id =
+            std::env::var("DEFAULT_MODEL").unwrap_or_else(|_| "gemma-3-1b-it".to_string());
 
         let gemma_config = GemmaInferenceConfig {
             model: None,
@@ -94,9 +94,6 @@ fn model_id_to_which(model_id: &str) -> Option<Which> {
     }
 }
 
-
-
-
 fn normalize_model_id(model_id: &str) -> String {
     model_id.to_lowercase().replace("_", "-")
 }
@@ -204,19 +201,21 @@ pub async fn chat_completions_non_streaming_proxy(
                     StatusCode::BAD_REQUEST,
                     Json(serde_json::json!({
                         "error": { "message": format!("Model {} is not a Llama model", model_id) }
-                    }))
+                    })),
                 ));
             }
         };
         let mut config = LlamaInferenceConfig::new(llama_model);
         config.prompt = prompt.clone();
         config.max_tokens = max_tokens;
-        run_llama_inference(config).map_err(|e| (
+        run_llama_inference(config).map_err(|e| {
-            StatusCode::INTERNAL_SERVER_ERROR,
+            (
-            Json(serde_json::json!({
+                StatusCode::INTERNAL_SERVER_ERROR,
-                "error": { "message": format!("Error initializing Llama model: {}", e) }
+                Json(serde_json::json!({
-            }))
+                    "error": { "message": format!("Error initializing Llama model: {}", e) }
-        ))?
+                })),
+            )
+        })?
     } else {
         // Create Gemma configuration dynamically
         let gemma_model = match which_model {
@@ -241,7 +240,7 @@ pub async fn chat_completions_non_streaming_proxy(
                     StatusCode::BAD_REQUEST,
                     Json(serde_json::json!({
                         "error": { "message": format!("Model {} is not a Gemma model", model_id) }
-                    }))
+                    })),
                 ));
             }
         };
@@ -252,12 +251,14 @@ pub async fn chat_completions_non_streaming_proxy(
         };
         config.prompt = prompt.clone();
         config.max_tokens = max_tokens;
-        run_gemma_api(config).map_err(|e| (
+        run_gemma_api(config).map_err(|e| {
-            StatusCode::INTERNAL_SERVER_ERROR,
+            (
-            Json(serde_json::json!({
+                StatusCode::INTERNAL_SERVER_ERROR,
-                "error": { "message": format!("Error initializing Gemma model: {}", e) }
+                Json(serde_json::json!({
-            }))
+                    "error": { "message": format!("Error initializing Gemma model: {}", e) }
-        ))?
+                })),
+            )
+        })?
     };
 
     // Collect all tokens from the stream
@@ -397,7 +398,7 @@ async fn handle_streaming_request(
                     StatusCode::INTERNAL_SERVER_ERROR,
                     Json(serde_json::json!({
                         "error": { "message": format!("Model {} is not a Llama model", model_id) }
-                    }))
+                    })),
                 ));
             }
         };
@@ -439,7 +440,7 @@ async fn handle_streaming_request(
                     StatusCode::INTERNAL_SERVER_ERROR,
                     Json(serde_json::json!({
                         "error": { "message": format!("Model {} is not a Gemma model", model_id) }
-                    }))
+                    })),
                 ));
             }
         };
@@ -605,59 +606,66 @@ pub async fn list_models() -> Json<ModelListResponse> {
         Which::Llama32_3BInstruct,
     ];
 
+    let mut models: Vec<Model> = which_variants
+        .into_iter()
+        .map(|which| {
+            let meta = which.meta();
+            let model_id = match which {
+                Which::Base2B => "gemma-2b",
+                Which::Base7B => "gemma-7b",
+                Which::Instruct2B => "gemma-2b-it",
+                Which::Instruct7B => "gemma-7b-it",
+                Which::InstructV1_1_2B => "gemma-1.1-2b-it",
+                Which::InstructV1_1_7B => "gemma-1.1-7b-it",
+                Which::CodeBase2B => "codegemma-2b",
+                Which::CodeBase7B => "codegemma-7b",
+                Which::CodeInstruct2B => "codegemma-2b-it",
+                Which::CodeInstruct7B => "codegemma-7b-it",
+                Which::BaseV2_2B => "gemma-2-2b",
+                Which::InstructV2_2B => "gemma-2-2b-it",
+                Which::BaseV2_9B => "gemma-2-9b",
+                Which::InstructV2_9B => "gemma-2-9b-it",
+                Which::BaseV3_1B => "gemma-3-1b",
+                Which::InstructV3_1B => "gemma-3-1b-it",
+                Which::Llama32_1B => "llama-3.2-1b",
+                Which::Llama32_1BInstruct => "llama-3.2-1b-instruct",
+                Which::Llama32_3B => "llama-3.2-3b",
+                Which::Llama32_3BInstruct => "llama-3.2-3b-instruct",
+            };
 
+            let owned_by = if meta.id.starts_with("google/") {
+                "google"
+            } else if meta.id.starts_with("meta-llama/") {
+                "meta"
+            } else {
+                "unknown"
+            };
 
-    let mut models: Vec<Model> = which_variants.into_iter().map(|which| {
+            Model {
-        let meta = which.meta();
+                id: model_id.to_string(),
-        let model_id = match which {
+                object: "model".to_string(),
-            Which::Base2B => "gemma-2b",
+                created: 1686935002,
-            Which::Base7B => "gemma-7b",
+                owned_by: owned_by.to_string(),
-            Which::Instruct2B => "gemma-2b-it",
+            }
-            Which::Instruct7B => "gemma-7b-it",
+        })
-            Which::InstructV1_1_2B => "gemma-1.1-2b-it",
+        .collect();
-            Which::InstructV1_1_7B => "gemma-1.1-7b-it",
-            Which::CodeBase2B => "codegemma-2b",
-            Which::CodeBase7B => "codegemma-7b",
-            Which::CodeInstruct2B => "codegemma-2b-it",
-            Which::CodeInstruct7B => "codegemma-7b-it",
-            Which::BaseV2_2B => "gemma-2-2b",
-            Which::InstructV2_2B => "gemma-2-2b-it",
-            Which::BaseV2_9B => "gemma-2-9b",
-            Which::InstructV2_9B => "gemma-2-9b-it",
-            Which::BaseV3_1B => "gemma-3-1b",
-            Which::InstructV3_1B => "gemma-3-1b-it",
-            Which::Llama32_1B => "llama-3.2-1b",
-            Which::Llama32_1BInstruct => "llama-3.2-1b-instruct",
-            Which::Llama32_3B => "llama-3.2-3b",
-            Which::Llama32_3BInstruct => "llama-3.2-3b-instruct",
-        };
-
-        let owned_by = if meta.id.starts_with("google/") {
-            "google"
-        } else if meta.id.starts_with("meta-llama/") {
-            "meta"
-        } else {
-            "unknown"
-        };
-
-        Model {
-            id: model_id.to_string(),
-            object: "model".to_string(),
-            created: 1686935002,
-            owned_by: owned_by.to_string(),
-        }
-    }).collect();
 
     // Get embeddings models and convert them to inference Model format
     let embeddings_response = models_list().await;
-    let embeddings_models: Vec<Model> = embeddings_response.0.data.into_iter().map(|embedding_model| {
+    let embeddings_models: Vec<Model> = embeddings_response
-        Model {
+        .0
+        .data
+        .into_iter()
+        .map(|embedding_model| Model {
             id: embedding_model.id,
             object: embedding_model.object,
             created: 1686935002,
-            owned_by: format!("{} - {}", embedding_model.owned_by, embedding_model.description),
+            owned_by: format!(
-        }
+                "{} - {}",
-    }).collect();
+                embedding_model.owned_by, embedding_model.description
+            ),
+        })
+        .collect();
 
     // Add embeddings models to the main models list
     models.extend(embeddings_models);

integration/gemma-runner/src/gemma_api.rs

@@ -1,4 +1,3 @@
-
 use anyhow::{Error as E, Result};
 use candle_transformers::models::gemma::{Config as Config1, Model as Model1};
 use candle_transformers::models::gemma2::{Config as Config2, Model as Model2};
@@ -11,13 +10,13 @@ use candle_transformers::generation::LogitsProcessor;
 use hf_hub::{api::sync::Api, Repo, RepoType};
 use std::io::Write;
 
+use std::fmt;
+use std::str::FromStr;
 use std::sync::mpsc::{self, Receiver, Sender};
 use std::thread;
 use tokenizers::Tokenizer;
 use utils::hub_load_safetensors;
 use utils::token_output_stream::TokenOutputStream;
-use std::str::FromStr;
-use std::fmt;
 
 #[derive(Clone, Debug, Copy, PartialEq, Eq, clap::ValueEnum)]
 pub enum WhichModel {
@@ -367,7 +366,9 @@ pub fn run_gemma_api(cfg: GemmaInferenceConfig) -> Result<Receiver<Result<String
     let tokenizer_filename = repo.get("tokenizer.json")?;
     let config_filename = repo.get("config.json")?;
     let filenames = match cfg.model {
-        Some(WhichModel::BaseV3_1B) | Some(WhichModel::InstructV3_1B) => vec![repo.get("model.safetensors")?],
+        Some(WhichModel::BaseV3_1B) | Some(WhichModel::InstructV3_1B) => {
+            vec![repo.get("model.safetensors")?]
+        }
         _ => hub_load_safetensors(&repo, "model.safetensors.index.json")?,
     };
     println!("Retrieved files in {:?}", start.elapsed());
@@ -396,7 +397,8 @@ pub fn run_gemma_api(cfg: GemmaInferenceConfig) -> Result<Receiver<Result<String
         | Some(WhichModel::InstructV2_2B)
         | Some(WhichModel::BaseV2_9B)
         | Some(WhichModel::InstructV2_9B)
-        | None => { // default to V2 model
+        | None => {
+            // default to V2 model
             let config: Config2 = serde_json::from_reader(std::fs::File::open(config_filename)?)?;
             let model = Model2::new(cfg.use_flash_attn, &config, vb)?;
             Model::V2(model)

integration/helm-chart-tool/src/main.rs

@@ -105,7 +105,9 @@ fn discover_services(workspace_path: &str) -> Result<Vec<ServiceInfo>> {
         .into_iter()
         .filter_map(|e| e.ok())
     {
-        if entry.file_name() == "Cargo.toml" && entry.path() != workspace_root.join("../../../Cargo.toml") {
+        if entry.file_name() == "Cargo.toml"
+            && entry.path() != workspace_root.join("../../../Cargo.toml")
+        {
             if let Ok(service_info) = parse_cargo_toml(entry.path()) {
                 services.push(service_info);
             }

integration/llama-runner/src/llama_api.rs

@@ -102,7 +102,7 @@ impl Default for LlamaInferenceConfig {
             max_tokens: 512,
 
             // Performance flags
-            no_kv_cache: false,   // keep cache ON for speed
+            no_kv_cache: false,    // keep cache ON for speed
             use_flash_attn: false, // great speed boost if supported
 
             // Precision: bf16 is a good default on Ampere+; fallback to fp16 if needed.

integration/utils/src/imagenet.rs

@@ -1,5 +1,5 @@
-use candle_transformers::models::mimi::candle;
 use candle_core::{Device, Result, Tensor};
+use candle_transformers::models::mimi::candle;
 
 pub const IMAGENET_MEAN: [f32; 3] = [0.485f32, 0.456, 0.406];
 pub const IMAGENET_STD: [f32; 3] = [0.229f32, 0.224, 0.225];

integration/utils/src/lib.rs

@@ -8,8 +8,10 @@ pub mod coco_classes;
 pub mod imagenet;
 pub mod token_output_stream;
 pub mod wav;
-use candle_core::{Device, Tensor, utils::{cuda_is_available, metal_is_available}};
+use candle_core::{
-
+    utils::{cuda_is_available, metal_is_available},
+    Device, Tensor,
+};
 
 pub fn device(cpu: bool) -> Result<Device, anyhow::Error> {
     if cpu {
@@ -126,7 +128,7 @@ pub fn hub_load_safetensors(
             repo.get(v)
                 .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))
         })
-        .collect::<Result<Vec<_>, std::io::Error, >>()?;
+        .collect::<Result<Vec<_>, std::io::Error>>()?;
     Ok(safetensors_files)
 }
 
@@ -136,7 +138,8 @@ pub fn hub_load_local_safetensors<P: AsRef<std::path::Path>>(
 ) -> Result<Vec<std::path::PathBuf>, anyhow::Error> {
     let path = path.as_ref();
     let jsfile = std::fs::File::open(path.join(json_file))?;
-    let json: serde_json::Value = serde_json::from_reader(&jsfile).map_err(candle_core::Error::wrap)?;
+    let json: serde_json::Value =
+        serde_json::from_reader(&jsfile).map_err(candle_core::Error::wrap)?;
     let weight_map = match json.get("weight_map") {
         None => anyhow::bail!("no weight map in {json_file:?}"),
         Some(serde_json::Value::Object(map)) => map,