formatting

src/ai_models/instance.rs

@@ -1,10 +1,10 @@
-use std::sync::Arc;
-use axum::http::StatusCode;
 use crate::models::chat::{ChatCompletionRequest, ChatCompletionResponse};
 use crate::models::completion::{CompletionRequest, CompletionResponse};
 use crate::models::embeddings::{EmbeddingsRequest, EmbeddingsResponse};
 use crate::providers::provider::Provider;
 use crate::state::AppState;
+use axum::http::StatusCode;
+use std::sync::Arc;
 
 pub struct ModelInstance {
     pub name: String,
@@ -28,7 +28,7 @@ impl ModelInstance {
         mut payload: CompletionRequest,
     ) -> Result<CompletionResponse, StatusCode> {
         payload.model = self.model_type.clone();
-        
+
         self.provider.completions(state, payload).await
     }
 

src/ai_models/registry.rs

@@ -1,11 +1,10 @@
+use anyhow::Result;
 use std::collections::HashMap;
 use std::sync::Arc;
-use anyhow::Result;
 
+use super::instance::ModelInstance;
 use crate::config::models::Model as ModelConfig;
 use crate::providers::registry::ProviderRegistry;
-use super::instance::ModelInstance;
-
 
 pub struct ModelRegistry {
     models: HashMap<String, Arc<ModelInstance>>,
@@ -17,22 +16,22 @@ impl ModelRegistry {
         provider_registry: Arc<ProviderRegistry>,
     ) -> Result<Self> {
         let mut models = HashMap::new();
-        
+
         for config in model_configs {
             if let Some(provider) = provider_registry.get(&config.provider) {
                 let model = Arc::new(ModelInstance {
                     name: config.name.clone(),
                     model_type: config.r#type.clone(),
                     provider,
                 });
-                
+
                 models.insert(config.name.clone(), model);
             }
         }
-        
+
         Ok(Self { models })
     }
-    
+
     pub fn get(&self, name: &str) -> Option<Arc<ModelInstance>> {
         self.models.get(name).cloned()
     }

src/config/mod.rs

@@ -1,2 +1,2 @@
-pub mod models;
 pub mod lib;
+pub mod models;

src/handlers/chat.rs

@@ -1,4 +1,7 @@
-use crate::{models::chat::{ChatCompletionRequest, ChatCompletionResponse}, state::AppState};
+use crate::{
+    models::chat::{ChatCompletionRequest, ChatCompletionResponse},
+    state::AppState,
+};
 use axum::{extract::State, http::StatusCode, Json};
 use std::sync::Arc;
 
@@ -8,7 +11,9 @@ pub async fn completions(
 ) -> Result<Json<ChatCompletionResponse>, StatusCode> {
     for model in state.config.models.iter() {
         if let Some(model) = state.model_registry.get(&model.name) {
-            let response = model.chat_completions(state.clone(), payload.clone()).await?;
+            let response = model
+                .chat_completions(state.clone(), payload.clone())
+                .await?;
             return Ok(Json(response));
         }
     }

src/handlers/completion.rs

@@ -1,4 +1,7 @@
-use crate::{models::completion::{CompletionRequest, CompletionResponse}, state::AppState};
+use crate::{
+    models::completion::{CompletionRequest, CompletionResponse},
+    state::AppState,
+};
 use axum::{extract::State, http::StatusCode, Json};
 use std::sync::Arc;
 

src/handlers/embeddings.rs

@@ -1,7 +1,10 @@
 use axum::{extract::State, http::StatusCode, Json};
 use std::sync::Arc;
 
-use crate::{models::embeddings::{EmbeddingsRequest, EmbeddingsResponse}, state::AppState};
+use crate::{
+    models::embeddings::{EmbeddingsRequest, EmbeddingsResponse},
+    state::AppState,
+};
 
 pub async fn embeddings(
     State(state): State<Arc<AppState>>,

src/main.rs

@@ -9,8 +9,10 @@ async fn main() -> Result<(), anyhow::Error> {
 
     info!("Starting the application...");
 
-    let config = load_config("config.yaml").map_err(|_| anyhow::anyhow!("Failed to load configuration"))?;
-    let state = Arc::new(AppState::new(config).map_err(|_| anyhow::anyhow!("Failed to create app state"))?);
+    let config =
+        load_config("config.yaml").map_err(|_| anyhow::anyhow!("Failed to load configuration"))?;
+    let state =
+        Arc::new(AppState::new(config).map_err(|_| anyhow::anyhow!("Failed to create app state"))?);
     let app = routes::create_router(state);
     let port: String = std::env::var("PORT").unwrap_or("3000".to_string());
     let listener = tokio::net::TcpListener::bind(format!("0.0.0.0:{}", port))

src/models/common.rs

@@ -5,4 +5,4 @@ pub struct Usage {
     pub prompt_tokens: u32,
     pub completion_tokens: u32,
     pub total_tokens: u32,
-}
+}

src/models/embeddings.rs

@@ -32,4 +32,4 @@ pub struct Embeddings {
     pub object: String,
     pub embedding: Vec<f32>,
     pub index: usize,
-}
+}

src/pipelines/mod.rs

@@ -1,4 +1,4 @@
+pub mod pipeline;
 pub mod plugin;
 pub mod plugins;
-pub mod pipeline;
 pub mod services;

src/pipelines/pipeline.rs

@@ -30,8 +30,6 @@ pub fn select_pipeline<'a>(
             .find(|p| p.name == pipeline_name)
     } else {
         // Default to pipeline named "default"
-        matching_pipelines
-            .into_iter()
-            .find(|p| p.name == "default")
+        matching_pipelines.into_iter().find(|p| p.name == "default")
     }
-}
+}

src/pipelines/plugin.rs

@@ -38,13 +38,11 @@ where
     fn call(&mut self, request: Request) -> Self::Future {
         if !self.plugin.enabled() {
             let future = self.inner.call(request);
-            return Box::pin(async move {
-                future.await
-            });
+            return Box::pin(async move { future.await });
         }
 
         let future = self.inner.call(request);
-        
+
         Box::pin(async move {
             let response = future.await?;
             // Here you can add post-processing logic

src/pipelines/plugins/logging.rs

@@ -1,5 +1,5 @@
-use crate::pipelines::plugin::Plugin;
 use crate::config::models::PluginConfig;
+use crate::pipelines::plugin::Plugin;
 
 pub struct LoggingPlugin;
 
@@ -12,9 +12,7 @@ impl Plugin for LoggingPlugin {
         true
     }
 
-    fn init(&mut self, _config: &PluginConfig) -> () {
-
-    }
+    fn init(&mut self, _config: &PluginConfig) -> () {}
 
     fn clone_box(&self) -> Box<dyn Plugin> {
         Box::new(LoggingPlugin)

src/pipelines/plugins/mod.rs

@@ -1,2 +1,2 @@
 pub mod logging;
-pub mod tracing;
+pub mod tracing;

src/pipelines/plugins/tracing.rs

@@ -1,5 +1,5 @@
-use crate::pipelines::plugin::Plugin;
 use crate::config::models::PluginConfig;
+use crate::pipelines::plugin::Plugin;
 
 pub struct TracingPlugin;
 
@@ -12,9 +12,7 @@ impl Plugin for TracingPlugin {
         true
     }
 
-    fn init(&mut self, _config: &PluginConfig) -> () {
-
-    }
+    fn init(&mut self, _config: &PluginConfig) -> () {}
 
     fn clone_box(&self) -> Box<dyn Plugin> {
         Box::new(TracingPlugin)

src/pipelines/services/mod.rs

@@ -1 +1 @@
-pub mod model_router;
+pub mod model_router;

src/pipelines/services/model_router.rs

@@ -1,13 +1,12 @@
-use std::sync::Arc;
-use tower::Service;
 use std::future::Future;
 use std::pin::Pin;
+use std::sync::Arc;
 use std::task::{Context, Poll};
+use tower::Service;
 
 use crate::models::chat::{ChatCompletionRequest, ChatCompletionResponse};
 use crate::state::AppState;
 
-
 pub struct ModelRouterService {
     state: Arc<AppState>,
     models: Vec<String>,
@@ -47,4 +46,4 @@ impl Service<ChatCompletionRequest> for ModelRouterService {
             Err(axum::http::StatusCode::SERVICE_UNAVAILABLE)
         })
     }
-} 
+}

src/providers/anthropic.rs

@@ -3,11 +3,13 @@ use axum::http::StatusCode;
 use std::sync::Arc;
 
 use super::provider::Provider;
+use crate::config::models::Provider as ProviderConfig;
 use crate::models::chat::{ChatCompletionRequest, ChatCompletionResponse};
 use crate::models::common::Usage;
-use crate::models::completion::{CompletionRequest, CompletionResponse, CompletionChoice};
-use crate::models::embeddings::{Embeddings, EmbeddingsInput, EmbeddingsRequest, EmbeddingsResponse};
-use crate::config::models::Provider as ProviderConfig;
+use crate::models::completion::{CompletionChoice, CompletionRequest, CompletionResponse};
+use crate::models::embeddings::{
+    Embeddings, EmbeddingsInput, EmbeddingsRequest, EmbeddingsResponse,
+};
 use crate::state::AppState;
 
 pub struct AnthropicProvider {
@@ -31,7 +33,7 @@ impl Provider for AnthropicProvider {
     fn r#type(&self) -> String {
         "anthropic".to_string()
     }
-    
+
     async fn chat_completions(
         &self,
         state: Arc<AppState>,
@@ -54,12 +56,11 @@ impl Provider for AnthropicProvider {
                 .await
                 .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)
         } else {
-            Err(StatusCode::from_u16(status.as_u16())
-                .unwrap_or(StatusCode::INTERNAL_SERVER_ERROR))
+            Err(StatusCode::from_u16(status.as_u16()).unwrap_or(StatusCode::INTERNAL_SERVER_ERROR))
         }
     }
 
-        async fn completions(
+    async fn completions(
         &self,
         state: Arc<AppState>,
         payload: CompletionRequest,
@@ -85,8 +86,9 @@ impl Provider for AnthropicProvider {
 
         let status = response.status();
         if !status.is_success() {
-            return Err(StatusCode::from_u16(status.as_u16())
-                .unwrap_or(StatusCode::INTERNAL_SERVER_ERROR));
+            return Err(
+                StatusCode::from_u16(status.as_u16()).unwrap_or(StatusCode::INTERNAL_SERVER_ERROR)
+            );
         }
 
         let anthropic_response: serde_json::Value = response
@@ -119,7 +121,7 @@ impl Provider for AnthropicProvider {
         })
     }
 
-        async fn embeddings(
+    async fn embeddings(
         &self,
         state: Arc<AppState>,
         payload: EmbeddingsRequest,
@@ -147,8 +149,9 @@ impl Provider for AnthropicProvider {
 
         let status = response.status();
         if !status.is_success() {
-            return Err(StatusCode::from_u16(status.as_u16())
-                .unwrap_or(StatusCode::INTERNAL_SERVER_ERROR));
+            return Err(
+                StatusCode::from_u16(status.as_u16()).unwrap_or(StatusCode::INTERNAL_SERVER_ERROR)
+            );
         }
 
         let anthropic_response: serde_json::Value = response

src/providers/mod.rs

@@ -1,4 +1,4 @@
 pub mod anthropic;
-pub mod registry;
-pub mod provider;
 pub mod openai;
+pub mod provider;
+pub mod registry;

src/providers/openai.rs

@@ -1,11 +1,11 @@
 use axum::async_trait;
 use axum::http::StatusCode;
 
-use crate::models::chat::{ChatCompletionRequest, ChatCompletionResponse};
 use crate::config::models::Provider as ProviderConfig;
-use crate::state::AppState;
+use crate::models::chat::{ChatCompletionRequest, ChatCompletionResponse};
 use crate::models::completion::{CompletionRequest, CompletionResponse};
 use crate::models::embeddings::{EmbeddingsRequest, EmbeddingsResponse};
+use crate::state::AppState;
 use std::sync::Arc;
 
 use super::provider::Provider;
@@ -51,8 +51,7 @@ impl Provider for OpenAIProvider {
                 .await
                 .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)
         } else {
-            Err(StatusCode::from_u16(status.as_u16())
-                .unwrap_or(StatusCode::INTERNAL_SERVER_ERROR))
+            Err(StatusCode::from_u16(status.as_u16()).unwrap_or(StatusCode::INTERNAL_SERVER_ERROR))
         }
     }
 
@@ -77,12 +76,11 @@ impl Provider for OpenAIProvider {
                 .await
                 .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)
         } else {
-            Err(StatusCode::from_u16(status.as_u16())
-                .unwrap_or(StatusCode::INTERNAL_SERVER_ERROR))
+            Err(StatusCode::from_u16(status.as_u16()).unwrap_or(StatusCode::INTERNAL_SERVER_ERROR))
         }
     }
 
-        async fn embeddings(
+    async fn embeddings(
         &self,
         state: Arc<AppState>,
         payload: EmbeddingsRequest,
@@ -103,8 +101,7 @@ impl Provider for OpenAIProvider {
                 .await
                 .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)
         } else {
-            Err(StatusCode::from_u16(status.as_u16())
-                .unwrap_or(StatusCode::INTERNAL_SERVER_ERROR))
+            Err(StatusCode::from_u16(status.as_u16()).unwrap_or(StatusCode::INTERNAL_SERVER_ERROR))
         }
     }
 }

src/providers/provider.rs

@@ -1,17 +1,18 @@
 use axum::async_trait;
 use axum::http::StatusCode;
 
+use crate::config::models::Provider as ProviderConfig;
 use crate::models::chat::{ChatCompletionRequest, ChatCompletionResponse};
 use crate::models::completion::{CompletionRequest, CompletionResponse};
-use crate::config::models::Provider as ProviderConfig;
 use crate::models::embeddings::{EmbeddingsRequest, EmbeddingsResponse};
 use crate::state::AppState;
 use std::sync::Arc;
 
-
 #[async_trait]
 pub trait Provider: Send + Sync {
-    fn new(config: &ProviderConfig) -> Self where Self: Sized;
+    fn new(config: &ProviderConfig) -> Self
+    where
+        Self: Sized;
     fn name(&self) -> String;
     fn r#type(&self) -> String;
 
@@ -20,7 +21,7 @@ pub trait Provider: Send + Sync {
         state: Arc<AppState>,
         payload: ChatCompletionRequest,
     ) -> Result<ChatCompletionResponse, StatusCode>;
-    
+
     async fn completions(
         &self,
         state: Arc<AppState>,