use crate::auth::merge_headers;
use crate::model_config::ModelConfig;
use crate::options::{ProviderHeaders, SimpleStreamOptions};
use crate::types::Model;
use serde_json::{Map, Value, json};
use std::path::Path;
use std::sync::Arc;
pub type Lookup<'a> = &'a dyn Fn(&str) -> Option<String>;
pub type SharedLookup = Arc<dyn Fn(&str) -> Option<String> + Send + Sync>;
#[derive(Clone, Debug, Default, PartialEq)]
pub struct StoredRequestAuth {
pub base_url: Option<String>,
pub headers: Option<ProviderHeaders>,
pub env: Option<crate::env::ProviderEnv>,
}
pub type StoredAuth = Arc<dyn Fn() -> Option<StoredRequestAuth> + Send + Sync>;
#[derive(Clone, Default)]
pub struct RequestConfig {
provider: String,
model: String,
provider_headers: Vec<(String, String)>,
model_headers: Vec<(String, String)>,
pub auth_header: bool,
lookup: Option<SharedLookup>,
pub stored_auth: Option<StoredAuth>,
}
impl std::fmt::Debug for RequestConfig {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("RequestConfig")
.field(
"provider_headers",
&self.provider_headers.iter().map(|(k, _)| k).collect::<Vec<_>>(),
)
.field(
"model_headers",
&self.model_headers.iter().map(|(k, _)| k).collect::<Vec<_>>(),
)
.field("auth_header", &self.auth_header)
.field("stored_auth", &self.stored_auth.is_some())
.finish()
}
}
impl PartialEq for RequestConfig {
fn eq(&self, other: &Self) -> bool {
(
&self.provider,
&self.model,
&self.provider_headers,
&self.model_headers,
self.auth_header,
) == (
&other.provider,
&other.model,
&other.provider_headers,
&other.model_headers,
other.auth_header,
)
}
}
impl RequestConfig {
pub fn headers(&self, provider: &str, key: Option<&str>) -> Result<Option<ProviderHeaders>, String> {
self.headers_in(provider, key, None, None)
}
pub fn headers_in(
&self,
provider: &str,
key: Option<&str>,
provider_env: Option<&crate::env::ProviderEnv>,
model_env: Option<&crate::env::ProviderEnv>,
) -> Result<Option<ProviderHeaders>, String> {
let base = |name: &str| self.lookup.as_ref().and_then(|lookup| lookup(name));
let over = |env: Option<&crate::env::ProviderEnv>, name: &str| {
env.and_then(|env| env.get(name))
.filter(|v| !v.is_empty())
.cloned()
.or_else(|| base(name))
};
let provider_lookup = |name: &str| over(provider_env, name);
let model_lookup = |name: &str| over(model_env, name);
self.headers_with_env(provider, key, &provider_lookup, &model_lookup)
}
fn headers_with(
&self,
provider: &str,
key: Option<&str>,
lookup: Lookup<'_>,
) -> Result<Option<ProviderHeaders>, String> {
self.headers_with_env(provider, key, lookup, lookup)
}
fn headers_with_env(
&self,
provider: &str,
key: Option<&str>,
lookup: Lookup<'_>,
model_lookup: Lookup<'_>,
) -> Result<Option<ProviderHeaders>, String> {
let mut headers = resolve_headers_or_err(
&self.provider_headers,
&format!("provider \"{}\"", self.provider),
lookup,
)
.map_err(|e| auth_failed(provider, &e))?;
if self.auth_header {
let key = key
.filter(|k| !k.is_empty())
.ok_or_else(|| auth_failed(provider, "authHeader requires a resolved API key"))?;
headers
.get_or_insert_default()
.insert("Authorization".into(), Some(format!("Bearer {key}")));
}
let model = resolve_headers_or_err(
&self.model_headers,
&format!("model \"{}/{}\"", self.provider, self.model),
model_lookup,
)?;
Ok(merge_headers(headers.as_ref(), model.as_ref()))
}
}
fn auth_failed(provider: &str, cause: &str) -> String {
format!("API key auth failed for provider {provider}: {cause}")
}
fn stored_request_auth(model: &Model) -> Option<StoredRequestAuth> {
(model.request.as_ref()?.stored_auth.as_ref()?)()
}
fn options_with(
model: &Model,
options: &SimpleStreamOptions,
stored: Option<&StoredRequestAuth>,
) -> Result<Option<SimpleStreamOptions>, String> {
let Some(request) = &model.request else {
return Ok(None);
};
let env = stored.and_then(|s| s.env.as_ref());
let model_env = match (env, options.base.env.as_ref()) {
(Some(stored), Some(own)) => {
let mut merged = stored.clone();
merged.extend(own.iter().map(|(k, v)| (k.clone(), v.clone())));
Some(merged)
}
(stored, own) => stored.or(own).cloned(),
};
let configured = request.headers_in(
&model.provider,
options.base.api_key.as_deref(),
env,
model_env.as_ref(),
)?;
let auth = merge_headers(stored.and_then(|s| s.headers.as_ref()), configured.as_ref());
if auth.is_none() && env.is_none() {
return Ok(None);
}
let mut options = options.clone();
options.base.headers = merge_headers(auth.as_ref(), options.base.headers.as_ref());
if let Some(env) = env {
let mut merged = env.clone();
merged.extend(options.base.env.take().unwrap_or_default());
options.base.env = Some(merged);
}
Ok(Some(options))
}
fn model_with(model: &Model, stored: Option<&StoredRequestAuth>) -> Option<Model> {
let base_url = stored?.base_url.clone()?;
let mut model = model.clone();
model.base_url = base_url;
Some(model)
}
pub fn prepare_request(
model: &Model,
options: &SimpleStreamOptions,
) -> Result<(Option<Model>, Option<SimpleStreamOptions>), String> {
let stored = stored_request_auth(model);
let routed = model_with(model, stored.as_ref());
let prepared = options_with(model, options, stored.as_ref())?;
Ok((routed, prepared))
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct RequestAuth {
pub api_key: Option<String>,
pub headers: Option<ProviderHeaders>,
}
use config::radius::DEFAULT_RADIUS_GATEWAY;
#[derive(Clone, Debug, Default)]
pub struct ModelRegistry {
config: ModelConfig,
stored: Map<String, Value>,
}
impl ModelRegistry {
pub fn new(config: ModelConfig) -> Self {
ModelRegistry {
config,
stored: Map::new(),
}
}
pub fn load(path: &Path, home: &Path) -> Self {
let mut registry = Self::new(ModelConfig::load_with_home(path.to_str(), home));
registry.stored = config::models_store::ModelsStore::beside(path).snapshot();
registry
}
pub fn radius_gateway(&self, provider: &str) -> Option<(String, String)> {
let config = self.provider_config(provider);
let custom = config.filter(|c| c.get("oauth").and_then(Value::as_str) == Some("radius"));
match custom.and_then(|c| Some((c, c.get("baseUrl")?.as_str()?))) {
Some((config, base_url)) => {
let trimmed = base_url
.strip_suffix("/v1/")
.or_else(|| base_url.strip_suffix("/v1"))
.unwrap_or(base_url);
let name = config.get("name").and_then(Value::as_str).unwrap_or(provider);
Some((name.to_string(), config::radius::normalize_radius_gateway_url(trimmed)))
}
None => (provider == "radius").then(|| ("Radius".to_string(), DEFAULT_RADIUS_GATEWAY.to_string())),
}
}
fn base_models(&self, provider: &str) -> Vec<Model> {
let Some((_, gateway)) = self.radius_gateway(provider) else {
let builtin: Vec<Model> = crate::models::builtin_models(provider).cloned().collect();
let overlay = crate::model_refresh::remote_overlay(
provider,
self.stored.get(provider),
crate::model_refresh::builtin_generated_at(),
);
return crate::model_refresh::merge_models(builtin, overlay);
};
let models: Vec<Model> = if gateway == DEFAULT_RADIUS_GATEWAY {
crate::models::builtin_models("radius")
.map(|m| Model {
provider: provider.to_string(),
..m.clone()
})
.collect()
} else {
Vec::new()
};
let stored = crate::model_refresh::radius_stored(provider, self.stored.get(provider));
crate::model_refresh::merge_models(models, stored)
}
pub fn import_legacy_radius(&mut self, credentials: &Value, store: &config::models_store::ModelsStore, now: i64) {
let providers: Vec<String> = self
.provider_ids()
.into_iter()
.filter(|p| self.radius_gateway(p).is_some() && !self.stored.contains_key(p))
.collect();
for provider in providers {
let Some(credential) = credentials.get(&provider).filter(|c| c["type"] == "oauth") else {
continue;
};
let Some(legacy) = credential
.get("gatewayConfig")
.and_then(|config| crate::model_refresh::radius_models_from_config(&provider, config))
.filter(|models| !models.is_empty())
else {
continue;
};
let entry = json!({"models": legacy, "checkedAt": now});
if store.write(&provider, entry.clone()).is_ok() {
self.stored.insert(provider, entry);
}
}
}
pub fn config(&self) -> &ModelConfig {
&self.config
}
fn provider_config(&self, provider: &str) -> Option<&Map<String, Value>> {
self.config.provider(provider).and_then(Value::as_object)
}
pub fn provider_ids(&self) -> Vec<String> {
let mut ids: Vec<String> = crate::models::builtin_providers().map(str::to_string).collect();
for id in self.config.provider_ids() {
if !ids.iter().any(|known| known == id) {
ids.push(id.to_string());
}
}
ids
}
fn compose(&self, provider: &str, config: &Map<String, Value>) -> Result<Vec<Model>, String> {
compose_over(provider, self.base_models(provider).iter(), config)
}
pub fn models(&self, provider: &str) -> Vec<Model> {
match self.provider_config(provider) {
Some(config) => self
.compose(provider, config)
.unwrap_or_else(|_| self.base_models(provider)),
None => self.base_models(provider),
}
}
pub fn all_models(&self) -> Vec<Model> {
self.provider_ids().iter().flat_map(|p| self.models(p)).collect()
}
pub fn find(&self, provider: &str, id: &str) -> Option<Model> {
match self.provider_config(provider) {
Some(config) => self.models(provider).into_iter().find(|m| m.id == id).or_else(|| {
let dynamic = crate::models::builtin_model(provider, id)?;
compose_over(provider, std::iter::once(dynamic), config)
.ok()?
.into_iter()
.find(|m| m.id == id)
}),
None => self
.base_models(provider)
.into_iter()
.find(|m| m.id == id)
.or_else(|| crate::models::builtin_model(provider, id).cloned()),
}
}
pub fn resolve_cli(
&self,
cli_provider: Option<&str>,
cli_model: &str,
cli_thinking: Option<&str>,
has_auth: &dyn Fn(&str) -> bool,
) -> crate::model_resolver::CliModel {
if let Some(model) = self.resolve_dynamic(cli_provider, cli_model) {
return crate::model_resolver::CliModel {
model: Some(model),
..Default::default()
};
}
crate::model_resolver::resolve_cli_model(
cli_provider,
Some(cli_model),
cli_thinking,
&self.all_models(),
has_auth,
)
}
fn resolve_dynamic(&self, cli_provider: Option<&str>, cli_model: &str) -> Option<Model> {
let dynamic = crate::claude_subscription::PROVIDER;
fn prefixed<'t>(text: &'t str, dynamic: &str) -> Option<&'t str> {
let head = text.get(..dynamic.len() + 1)?;
head.eq_ignore_ascii_case(&format!("{dynamic}/"))
.then(|| &text[dynamic.len() + 1..])
}
let id = match cli_provider {
Some(p) if p.eq_ignore_ascii_case(dynamic) => prefixed(cli_model, dynamic).unwrap_or(cli_model),
Some(_) => return None,
None => prefixed(cli_model, dynamic)?,
};
if self.models(dynamic).iter().any(|m| m.id.eq_ignore_ascii_case(id)) {
return None;
}
self.find(dynamic, id)
}
pub fn resolve(&self, cli_provider: Option<&str>, cli_model: &str) -> Result<Model, String> {
let resolved = self.resolve_cli(cli_provider, cli_model, None, &|_| false);
match (resolved.model, resolved.error) {
(Some(model), _) => Ok(model),
(None, error) => Err(error.unwrap_or_else(|| format!("Model \"{cli_model}\" not found"))),
}
}
pub fn error(&self) -> Option<String> {
let mut errors: Vec<String> = self.config.error().map(str::to_string).into_iter().collect();
for provider in self.provider_ids() {
let composed = match self.provider_config(&provider) {
Some(config) => self.compose(&provider, config).map(|_| ()),
None => Ok(()),
};
if let Err(error) = composed {
errors.push(format!("Provider \"{provider}\": {error}"));
}
}
(!errors.is_empty()).then(|| errors.join("\n\n"))
}
fn raw_key(&self, provider: &str) -> Option<&str> {
let config = self.provider_config(provider)?;
self.compose(provider, config).ok()?;
config.get("apiKey").and_then(Value::as_str)
}
pub fn auth_configured(&self, provider: &str, lookup: Lookup<'_>, inherited: bool) -> bool {
match self.raw_key(provider) {
Some(raw) if config::auth::is_command(raw) => true,
Some(raw) => config::auth::env_names(raw)
.iter()
.all(|name| lookup(name).is_some_and(|v| !v.trim().is_empty())),
None if provider == crate::claude_code::PROVIDER => {
crate::claude_code::configured(&crate::env::EnvSource {
lookup,
exists: &|path: &Path| path.exists(),
home: lookup("HOME").map(std::path::PathBuf::from),
})
}
None => inherited,
}
}
pub fn api_key(
&self,
provider: &str,
override_key: Option<&str>,
lookup: Lookup<'_>,
inherited: Option<String>,
) -> Result<Option<String>, String> {
if let Some(key) = override_key {
return Ok(Some(key.to_string()));
}
match self.raw_key(provider) {
Some(raw) => {
config::auth::resolve_or_err(raw, &format!("API key for provider \"{provider}\""), lookup, &[])
.map(Some)
.map_err(|e| auth_failed(provider, &e))
}
None => Ok(inherited),
}
}
pub fn request_config(&self, model: &Model, lookup: Option<SharedLookup>) -> Option<RequestConfig> {
let config = self.provider_config(&model.provider)?;
let strings = |value: Option<&Value>| -> Vec<(String, String)> {
value
.and_then(Value::as_object)
.map(|map| {
map.iter()
.filter_map(|(k, v)| Some((k.clone(), v.as_str()?.to_string())))
.collect()
})
.unwrap_or_default()
};
let mut model_headers: Vec<(String, String)> = strings(
config
.get("modelOverrides")
.and_then(|o| o.get(&model.id))
.and_then(|o| o.get("headers")),
);
let definition = config
.get("models")
.and_then(Value::as_array)
.and_then(|models| models.iter().find(|m| m["id"].as_str() == Some(model.id.as_str())));
for (key, value) in strings(definition.and_then(|d| d.get("headers"))) {
match model_headers.iter_mut().find(|(k, _)| *k == key) {
Some(entry) => entry.1 = value,
None => model_headers.push((key, value)),
}
}
Some(RequestConfig {
provider: model.provider.clone(),
model: model.id.clone(),
provider_headers: strings(config.get("headers")),
model_headers,
auth_header: config.get("authHeader").and_then(Value::as_bool).unwrap_or(false),
lookup,
stored_auth: None,
})
}
pub fn for_requests(&self, mut model: Model, lookup: SharedLookup) -> Model {
model.request = self.request_config(&model, Some(lookup));
model
}
pub fn request_auth(
&self,
model: &Model,
override_key: Option<&str>,
lookup: Lookup<'_>,
inherited: Option<String>,
) -> Result<Option<RequestAuth>, String> {
let Some(api_key) = self.api_key(&model.provider, override_key, lookup, inherited)? else {
return Ok(None);
};
let headers = match self.request_config(model, None) {
Some(request) => request.headers_with(&model.provider, Some(&api_key), lookup)?,
None => None,
};
Ok(Some(RequestAuth {
api_key: Some(api_key),
headers,
}))
}
}
fn compose_over<'a>(
provider: &str,
base: impl Iterator<Item = &'a Model>,
config: &Map<String, Value>,
) -> Result<Vec<Model>, String> {
let base: Vec<Value> = base.map(|m| serde_json::to_value(m).unwrap_or(Value::Null)).collect();
let models = apply_models_json(provider, base, config)?;
let overrides = config.get("modelOverrides").and_then(Value::as_object);
models
.into_iter()
.map(|model| {
let id = model["id"].as_str().unwrap_or_default().to_string();
let model = match overrides.and_then(|o| o.get(&id)).and_then(Value::as_object) {
Some(ov) => apply_model_override(model, ov),
None => model,
};
serde_json::from_value(model).map_err(|e| format!("Provider {provider}, model {id}: {e}"))
})
.collect()
}
fn get<'a>(map: &'a Map<String, Value>, key: &str) -> Option<&'a Value> {
map.get(key).filter(|v| !v.is_null())
}
fn set(map: &mut Map<String, Value>, key: &str, value: Option<Value>) {
match value {
Some(value) => {
map.insert(key.to_string(), value);
}
None => {
map.remove(key);
}
}
}
fn spread(a: Option<&Value>, b: Option<&Value>) -> Value {
let mut out = Map::new();
for value in [a, b].into_iter().flatten() {
if let Some(map) = value.as_object() {
for (k, v) in map {
out.insert(k.clone(), v.clone());
}
}
}
Value::Object(out)
}
fn merge_compat(base: Option<&Value>, override_: Option<&Value>) -> Option<Value> {
let Some(override_) = override_ else {
return base.cloned();
};
let mut merged = spread(base, Some(override_));
let merged_map = merged.as_object_mut()?;
for key in [
"openRouterRouting",
"vercelGatewayRouting",
"chatTemplateKwargs",
"chatTemplateArgs",
] {
let base_value = base.and_then(|b| b.get(key));
let override_value = override_.get(key);
if base_value.is_some_and(Value::is_object) || override_value.is_some_and(Value::is_object) {
merged_map.insert(key.to_string(), spread(base_value, override_value));
}
}
Some(merged)
}
fn merge_input_limits(base: Option<&Value>, override_: Option<&Value>) -> Option<Value> {
let Some(override_) = override_ else {
return base.cloned();
};
let mut merged = spread(base, Some(override_));
let base_images = base.and_then(|b| b.get("images")).filter(|v| !v.is_null());
let images = match override_.get("images").filter(|v| !v.is_null()) {
Some(images) => {
let mut out = spread(base_images, Some(images));
let base_resize = base_images.and_then(|i| i.get("resize")).filter(|v| !v.is_null());
let resize = match images.get("resize").filter(|v| !v.is_null()) {
Some(resize) => Some(spread(base_resize, Some(resize))),
None => base_resize.cloned(),
};
if let Some(map) = out.as_object_mut() {
set(map, "resize", resize);
}
Some(out)
}
None => base_images.cloned(),
};
if let Some(map) = merged.as_object_mut() {
set(map, "images", images);
}
Some(merged)
}
fn apply_model_override(model: Value, ov: &Map<String, Value>) -> Value {
let Value::Object(mut model) = model else {
return model;
};
let keep = |model: &Map<String, Value>, key: &str| get(ov, key).or_else(|| get(model, key)).cloned();
let name = keep(&model, "name");
set(&mut model, "name", name);
let reasoning = keep(&model, "reasoning");
set(&mut model, "reasoning", reasoning);
if let Some(map) = get(ov, "thinkingLevelMap") {
let merged = spread(get(&model, "thinkingLevelMap"), Some(map));
model.insert("thinkingLevelMap".into(), merged);
}
let input = keep(&model, "input");
set(&mut model, "input", input);
let limits = merge_input_limits(get(&model, "inputLimits"), get(ov, "inputLimits"));
set(&mut model, "inputLimits", limits);
if let Some(cost) = get(ov, "cost").and_then(Value::as_object) {
let base = get(&model, "cost")
.and_then(Value::as_object)
.cloned()
.unwrap_or_default();
let mut merged = Map::new();
for key in ["input", "output", "cacheRead", "cacheWrite", "tiers"] {
if let Some(value) = get(cost, key).or_else(|| get(&base, key)) {
merged.insert(key.into(), value.clone());
}
}
model.insert("cost".into(), Value::Object(merged));
}
if let Some(cache) = get(ov, "promptCache") {
let merged = spread(get(&model, "promptCache"), Some(cache));
model.insert("promptCache".into(), merged);
}
for key in ["contextWindow", "maxTokens"] {
let value = keep(&model, key);
set(&mut model, key, value);
}
if let Some(params) = get(ov, "samplingParams") {
let merged = spread(get(&model, "samplingParams"), Some(params));
model.insert("samplingParams".into(), merged);
}
let compat = merge_compat(get(&model, "compat"), get(ov, "compat"));
set(&mut model, "compat", compat);
Value::Object(model)
}
fn model_from_json(
provider: &str,
definition: &Map<String, Value>,
config: &Map<String, Value>,
defaults: Option<&Map<String, Value>>,
) -> Result<Value, String> {
let id = definition.get("id").and_then(Value::as_str).unwrap_or_default();
let pick = |key: &str| {
get(definition, key)
.or_else(|| get(config, key))
.or_else(|| defaults.and_then(|d| get(d, key)))
.cloned()
};
let api = pick("api").ok_or_else(|| {
format!("Provider {provider}, model {id}: no \"api\" specified. Set at provider or model level.")
})?;
let base_url = pick("baseUrl")
.ok_or_else(|| format!("Provider {provider}: \"baseUrl\" is required when defining custom models."))?;
for (key, name) in [("contextWindow", "contextWindow"), ("maxTokens", "maxTokens")] {
if get(definition, key).and_then(Value::as_f64).is_some_and(|n| n <= 0.0) {
return Err(format!("Provider {provider}, model {id}: invalid {name}"));
}
}
let mut model = Map::new();
let mut put = |key: &str, value: Option<Value>| {
if let Some(value) = value {
model.insert(key.to_string(), value);
}
};
put("id", Some(json!(id)));
put(
"name",
Some(get(definition, "name").cloned().unwrap_or_else(|| json!(id))),
);
put("api", Some(api));
put("provider", Some(json!(provider)));
put("baseUrl", Some(base_url));
put(
"reasoning",
Some(get(definition, "reasoning").cloned().unwrap_or(json!(false))),
);
put("thinkingLevelMap", get(definition, "thinkingLevelMap").cloned());
put(
"input",
Some(get(definition, "input").cloned().unwrap_or(json!(["text"]))),
);
put("inputLimits", get(definition, "inputLimits").cloned());
put(
"cost",
Some(
get(definition, "cost")
.cloned()
.unwrap_or(json!({"input": 0, "output": 0, "cacheRead": 0, "cacheWrite": 0})),
),
);
put("promptCache", get(definition, "promptCache").cloned());
put(
"contextWindow",
Some(get(definition, "contextWindow").cloned().unwrap_or(json!(128000))),
);
put(
"maxTokens",
Some(get(definition, "maxTokens").cloned().unwrap_or(json!(16384))),
);
put("samplingParams", get(definition, "samplingParams").cloned());
put("compat", merge_compat(get(config, "compat"), get(definition, "compat")));
Ok(Value::Object(model))
}
fn find_defaults<'a>(models: &'a [Value], id: &str, api: Option<&str>) -> Option<&'a Map<String, Value>> {
let find = |key: &str, value: &str| models.iter().find(|m| m[key].as_str() == Some(value));
find("id", id)
.or_else(|| api.and_then(|api| find("api", api)))
.or_else(|| find("api", "openai-completions"))
.or_else(|| models.first())
.and_then(Value::as_object)
}
fn apply_models_json(provider: &str, base: Vec<Value>, config: &Map<String, Value>) -> Result<Vec<Value>, String> {
let oauth = get(config, "oauth");
let base_url = get(config, "baseUrl");
if oauth.is_some() && base_url.is_none() {
return Err(format!(
"Provider {provider}: \"baseUrl\" is required when \"oauth\" is set."
));
}
let definitions: &[Value] = get(config, "models")
.and_then(Value::as_array)
.map_or(&[], Vec::as_slice);
let has_overrides = get(config, "modelOverrides")
.and_then(Value::as_object)
.is_some_and(|o| !o.is_empty());
if definitions.is_empty()
&& base_url.is_none()
&& get(config, "headers").is_none()
&& get(config, "compat").is_none()
&& !has_overrides
&& get(config, "apiKey").is_none()
&& oauth.is_none()
&& !config.contains_key("authHeader")
{
return Err(format!(
"Provider {provider}: must specify \"baseUrl\", \"headers\", \"compat\", \"modelOverrides\", or \"models\"."
));
}
let radius = oauth.and_then(Value::as_str) == Some("radius");
let mut models: Vec<Value> = base
.into_iter()
.map(|model| {
let Value::Object(mut model) = model else {
return model;
};
if !radius && let Some(url) = base_url {
model.insert("baseUrl".into(), url.clone());
}
let compat = merge_compat(get(&model, "compat"), get(config, "compat"));
set(&mut model, "compat", compat);
Value::Object(model)
})
.collect();
for definition in definitions {
let Some(definition) = definition.as_object() else {
continue;
};
let id = definition.get("id").and_then(Value::as_str).unwrap_or_default();
let api = get(definition, "api")
.or_else(|| get(config, "api"))
.and_then(Value::as_str);
let defaults = find_defaults(&models, id, api).cloned();
let model = model_from_json(provider, definition, config, defaults.as_ref())?;
match models.iter().position(|m| m["id"].as_str() == Some(id)) {
Some(index) => models[index] = model,
None => models.push(model),
}
}
Ok(models)
}
fn resolve_headers_or_err(
headers: &[(String, String)],
description: &str,
lookup: Lookup<'_>,
) -> Result<Option<ProviderHeaders>, String> {
let resolved = config::auth::resolve_headers_or_err(headers, description, lookup, &[])?;
Ok(resolved.map(|pairs| pairs.into_iter().map(|(k, v)| (k, Some(v))).collect()))
}