use provider/model to identify models

crates/brightstaff/src/handlers/chat_completions.rs

@@ -104,7 +104,7 @@ pub async fn chat_completions(
 
     debug!("usage preferences: {:?}", usage_preferences);
 
-    let mut selected_llm = match router_service
+    let mut determined_route = match router_service
         .determine_route(
             &chat_completion_request.messages,
             trace_parent.clone(),
@@ -121,14 +121,14 @@ pub async fn chat_completions(
         }
     };
 
-    if selected_llm.is_none() {
+    if determined_route.is_none() {
         debug!("No LLM model selected, using default from request");
-        selected_llm = Some(chat_completion_request.model.clone());
+        determined_route = Some(chat_completion_request.model.clone());
     }
 
     info!(
         "sending request to llm provider: {} with llm model: {:?}",
-        llm_provider_endpoint, selected_llm
+        llm_provider_endpoint, determined_route
     );
 
     if let Some(trace_parent) = trace_parent {
@@ -138,10 +138,10 @@ pub async fn chat_completions(
         );
     }
 
-    if let Some(selected_llm) = selected_llm {
+    if let Some(selected_route) = determined_route {
         request_headers.insert(
             ARCH_PROVIDER_HINT_HEADER,
-            header::HeaderValue::from_str(&selected_llm).unwrap(),
+            header::HeaderValue::from_str(&selected_route).unwrap(),
         );
     }
 

crates/brightstaff/src/main.rs

@@ -45,8 +45,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     let bind_address = env::var("BIND_ADDRESS").unwrap_or_else(|_| BIND_ADDRESS.to_string());
 
     // loading arch_config.yaml file
-    let arch_config_path =
-        env::var("ARCH_CONFIG_PATH").unwrap_or_else(|_| "./arch_config.yaml".to_string());
+    let arch_config_path = env::var("ARCH_CONFIG_PATH_RENDERED")
+        .unwrap_or_else(|_| "./arch_config_rendered.yaml".to_string());
     info!("Loading arch_config.yaml from {}", arch_config_path);
 
     let config_contents =

crates/brightstaff/src/router/llm_router.rs

@@ -1,4 +1,4 @@
-use std::{collections::HashMap, sync::Arc};
+use std::sync::Arc;
 
 use common::{
     configuration::{LlmProvider, LlmRoute, ModelUsagePreference},
@@ -19,7 +19,6 @@ pub struct RouterService {
     router_model: Arc<dyn RouterModel>,
     routing_provider_name: String,
     llm_usage_defined: bool,
-    llm_provider_map: HashMap<String, LlmProvider>,
 }
 
 #[derive(Debug, Error)]
@@ -57,18 +56,12 @@ impl RouterService {
             router_model_v1::MAX_TOKEN_LEN,
         ));
 
-        let llm_provider_map: HashMap<String, LlmProvider> = providers
-            .into_iter()
-            .map(|provider| (provider.name.clone(), provider))
-            .collect();
-
         RouterService {
             router_url,
             client: reqwest::Client::new(),
             router_model,
             routing_provider_name,
             llm_usage_defined: !providers_with_usage.is_empty(),
-            llm_provider_map,
         }
     }
 
@@ -155,40 +148,15 @@ impl RouterService {
         if let Some(ContentType::Text(content)) =
             &chat_completion_response.choices[0].message.content
         {
-            let mut selected_model: Option<String> = None;
-            if let Some(selected_llm_name) = self.router_model.parse_response(content)? {
-                if selected_llm_name != "other" {
-                    if let Some(usage_preferences) = usage_preferences {
-                        for usage in usage_preferences {
-                            if usage.name == selected_llm_name {
-                                selected_model = Some(usage.model);
-                                break;
-                            }
-                        }
-                        if selected_model.is_none() {
-                            warn!(
-                                "Selected LLM model not found in usage preferences: {}",
-                                selected_llm_name
-                            );
-                        }
-                    } else if let Some(provider) = self.llm_provider_map.get(&selected_llm_name) {
-                        selected_model = provider.model.clone();
-                    } else {
-                        warn!(
-                            "Selected LLM model not found in provider map: {}",
-                            selected_llm_name
-                        );
-                    }
-                }
-            }
+            let route_name = self.router_model.parse_response(content)?;
             info!(
                 "router response: {}, selected_model: {:?}, response time: {}ms",
                 content.replace("\n", "\\n"),
-                selected_model,
+                route_name,
                 router_response_time.as_millis()
             );
 
-            Ok(selected_model)
+            Ok(route_name)
         } else {
             Ok(None)
         }