Show custom provider models in picker

Author: alecuba16

crates/jcode-base/src/provider/catalog_routes.rs

@@ -389,8 +389,92 @@ fn append_openai_routes(
     }
 }
 
-/// Configured OpenAI-compatible profiles (NVIDIA NIM, Groq, ...), excluding
-/// the active direct profile which contributes through the OpenRouter path.
+fn named_provider_profile_routes(
+    profile_name: &str,
+    profile: &crate::config::NamedProviderConfig,
+) -> Vec<ModelRoute> {
+    let mut models = profile
+        .models
+        .iter()
+        .filter(|model| {
+            model.input.is_empty()
+                || model
+                    .input
+                    .iter()
+                    .any(|input| input.eq_ignore_ascii_case("text"))
+        })
+        .map(|model| model.id.trim().to_string())
+        .filter(|model| !model.is_empty())
+        .collect::<Vec<_>>();
+
+    let default_model = profile
+        .default_model
+        .as_deref()
+        .map(str::trim)
+        .filter(|model| !model.is_empty());
+    if let Some(default_model) = default_model {
+        if !models.iter().any(|model| model == default_model) {
+            models.push(default_model.to_string());
+        }
+    }
+
+    let available = match profile.auth {
+        crate::config::NamedProviderAuth::None => true,
+        crate::config::NamedProviderAuth::Bearer | crate::config::NamedProviderAuth::Header => {
+            profile
+                .requires_api_key
+                .map(|requires_key| !requires_key)
+                .unwrap_or(false)
+                || profile
+                    .api_key
+                    .as_deref()
+                    .map(str::trim)
+                    .is_some_and(|key| !key.is_empty())
+                || profile
+                    .api_key_env
+                    .as_deref()
+                    .map(str::trim)
+                    .filter(|key_env| !key_env.is_empty())
+                    .is_some_and(|key_env| {
+                        std::env::var_os(key_env).is_some()
+                            || profile
+                                .env_file
+                                .as_deref()
+                                .map(str::trim)
+                                .filter(|env_file| !env_file.is_empty())
+                                .is_some_and(|env_file| {
+                                    crate::provider_catalog::load_env_value_from_env_or_config(
+                                        key_env, env_file,
+                                    )
+                                    .is_some()
+                                })
+                    })
+        }
+    };
+    let detail = if available {
+        profile.base_url.clone()
+    } else {
+        "no credentials".to_string()
+    };
+    let api_method = format!("openai-compatible:{profile_name}");
+
+    models
+        .into_iter()
+        .filter(|model| is_listable_model_name(model))
+        .map(|model| ModelRoute {
+            model,
+            provider: profile_name.to_string(),
+            api_method: api_method.clone(),
+            available,
+            detail: detail.clone(),
+            cheapness: None,
+        })
+        .collect()
+}
+
+/// Configured OpenAI-compatible profiles (NVIDIA NIM, Groq, ...), plus custom
+/// `[providers.<name>]` profiles, excluding the active direct profile which
+/// contributes through the OpenRouter path.
 /// Returns whether any routes were added.
 fn append_openai_compatible_profile_routes(
     provider: &MultiProvider,
@@ -423,6 +507,17 @@ fn append_openai_compatible_profile_routes(
         added_any |= !profile_routes.is_empty();
         routes.extend(profile_routes);
     }
+
+    for (profile_name, profile) in &crate::config::config().providers {
+        let api_method = format!("openai-compatible:{profile_name}");
+        if active_direct_openai_compatible_api_method.as_deref() == Some(api_method.as_str()) {
+            continue;
+        }
+
+        let profile_routes = named_provider_profile_routes(profile_name, profile);
+        added_any |= !profile_routes.is_empty();
+        routes.extend(profile_routes);
+    }
     added_any
 }
 
@@ -1188,6 +1283,38 @@ mod tests {
         }
     }
 
+    #[test]
+    fn named_provider_profile_routes_include_configured_text_models() {
+        let profile = crate::config::NamedProviderConfig {
+            base_url: "https://llm.example.test/v1".to_string(),
+            auth: crate::config::NamedProviderAuth::None,
+            default_model: Some("gateway/default-model".to_string()),
+            models: vec![
+                crate::config::NamedProviderModelConfig {
+                    id: "gateway/text-model".to_string(),
+                    input: vec!["text".to_string()],
+                    ..Default::default()
+                },
+                crate::config::NamedProviderModelConfig {
+                    id: "gateway/image-only".to_string(),
+                    input: vec!["image".to_string()],
+                    ..Default::default()
+                },
+            ],
+            ..Default::default()
+        };
+
+        let routes = named_provider_profile_routes("my-gateway", &profile);
+        let models = routes.iter().map(|route| route.model.as_str()).collect::<Vec<_>>();
+
+        assert_eq!(models, vec!["gateway/text-model", "gateway/default-model"]);
+        assert!(routes.iter().all(|route| route.provider == "my-gateway"));
+        assert!(routes
+            .iter()
+            .all(|route| route.api_method == "openai-compatible:my-gateway"));
+        assert!(routes.iter().all(|route| route.available));
+    }
+
     #[test]
     fn remote_compatible_route_uses_live_cache_and_does_not_mark_fallback() {
         let guard = EnvGuard::new();