feat(core): support custom model aliases in config.toml

Preserve custom model alias support on the current origin/main base and collapse the branch back to a single commit for easier future restacks.
This commit is contained in:
Friel
2026-03-28 11:35:15 -07:00
parent 65f631c3d6
commit d6f8e3aeeb
28 changed files with 732 additions and 139 deletions
+98 -4
View File
@@ -7,6 +7,7 @@ use crate::auth::CodexAuth;
use crate::auth_env_telemetry::AuthEnvTelemetry;
use crate::auth_env_telemetry::collect_auth_env_telemetry;
use crate::config::Config;
use crate::config::CustomModelConfig;
use crate::default_client::build_reqwest_client;
use crate::error::CodexErr;
use crate::error::Result as CoreResult;
@@ -28,6 +29,8 @@ use codex_protocol::openai_models::ModelInfo;
use codex_protocol::openai_models::ModelPreset;
use codex_protocol::openai_models::ModelsResponse;
use http::HeaderMap;
use std::collections::HashMap;
use std::collections::HashSet;
use std::fmt;
use std::path::PathBuf;
use std::sync::Arc;
@@ -175,6 +178,7 @@ enum CatalogMode {
#[derive(Debug)]
pub struct ModelsManager {
remote_models: RwLock<Vec<ModelInfo>>,
custom_models: HashMap<String, CustomModelConfig>,
catalog_mode: CatalogMode,
collaboration_modes_config: CollaborationModesConfig,
auth_manager: Arc<AuthManager>,
@@ -193,12 +197,14 @@ impl ModelsManager {
codex_home: PathBuf,
auth_manager: Arc<AuthManager>,
model_catalog: Option<ModelsResponse>,
custom_models: HashMap<String, CustomModelConfig>,
collaboration_modes_config: CollaborationModesConfig,
) -> Self {
Self::new_with_provider(
codex_home,
auth_manager,
model_catalog,
custom_models,
collaboration_modes_config,
ModelProviderInfo::create_openai_provider(/*base_url*/ None),
)
@@ -209,6 +215,7 @@ impl ModelsManager {
codex_home: PathBuf,
auth_manager: Arc<AuthManager>,
model_catalog: Option<ModelsResponse>,
custom_models: HashMap<String, CustomModelConfig>,
collaboration_modes_config: CollaborationModesConfig,
provider: ModelProviderInfo,
) -> Self {
@@ -227,6 +234,7 @@ impl ModelsManager {
});
Self {
remote_models: RwLock::new(remote_models),
custom_models,
catalog_mode,
collaboration_modes_config,
auth_manager,
@@ -313,7 +321,7 @@ impl ModelsManager {
#[instrument(level = "info", skip(self, config), fields(model = model))]
pub async fn get_model_info(&self, model: &str, config: &Config) -> ModelInfo {
let remote_models = self.get_remote_models().await;
Self::construct_model_info_from_candidates(model, &remote_models, config)
self.construct_model_info_from_candidates(model, &remote_models, config)
}
fn find_model_by_longest_prefix(model: &str, candidates: &[ModelInfo]) -> Option<ModelInfo> {
@@ -353,10 +361,41 @@ impl ModelsManager {
}
fn construct_model_info_from_candidates(
&self,
model: &str,
candidates: &[ModelInfo],
config: &Config,
) -> ModelInfo {
let custom_model = config
.custom_model_alias(model)
.or_else(|| self.custom_models.get(model));
Self::construct_model_info_from_candidates_with_custom(
model,
candidates,
config,
custom_model,
)
}
fn construct_model_info_from_candidates_with_custom(
model: &str,
candidates: &[ModelInfo],
config: &Config,
custom_model: Option<&CustomModelConfig>,
) -> ModelInfo {
if let Some(custom_model) = custom_model {
let mut config = config.clone();
config.model_context_window = custom_model
.model_context_window
.or(config.model_context_window);
config.model_auto_compact_token_limit = custom_model
.model_auto_compact_token_limit
.or(config.model_auto_compact_token_limit);
let model_info =
Self::construct_model_info_for_custom_alias(model, custom_model, candidates);
return model_info::with_config_overrides(model_info, &config);
}
// First use the normal longest-prefix match. If that misses, allow a narrowly scoped
// retry for namespaced slugs like `custom/gpt-5.3-codex`.
let remote = Self::find_model_by_longest_prefix(model, candidates)
@@ -373,6 +412,30 @@ impl ModelsManager {
model_info::with_config_overrides(model_info, config)
}
fn construct_model_info_for_custom_alias(
alias: &str,
custom_model: &CustomModelConfig,
candidates: &[ModelInfo],
) -> ModelInfo {
let remote = Self::find_model_by_longest_prefix(&custom_model.model, candidates)
.or_else(|| Self::find_model_by_namespaced_suffix(&custom_model.model, candidates));
if let Some(remote) = remote {
ModelInfo {
slug: alias.to_string(),
request_model: Some(custom_model.model.clone()),
display_name: alias.to_string(),
used_fallback_model_metadata: false,
..remote
}
} else {
let mut fallback_model = model_info::model_info_from_slug(&custom_model.model);
fallback_model.slug = alias.to_string();
fallback_model.request_model = Some(custom_model.model.clone());
fallback_model.display_name = alias.to_string();
fallback_model
}
}
/// Refresh models if the provided ETag differs from the cached ETag.
///
/// Uses `Online` strategy to fetch latest models when ETags differ.
@@ -520,12 +583,37 @@ impl ModelsManager {
fn build_available_models(&self, mut remote_models: Vec<ModelInfo>) -> Vec<ModelPreset> {
remote_models.sort_by(|a, b| a.priority.cmp(&b.priority));
let mut presets: Vec<ModelPreset> = remote_models.into_iter().map(Into::into).collect();
let mut presets: Vec<ModelPreset> = remote_models.iter().cloned().map(Into::into).collect();
let mut existing_models: HashSet<String> =
presets.iter().map(|preset| preset.model.clone()).collect();
let mut custom_presets = Vec::new();
let mut custom_models = self.custom_models.iter().collect::<Vec<_>>();
custom_models.sort_by(|(left, _), (right, _)| left.cmp(right));
for (alias, custom) in custom_models {
if existing_models.contains(alias) {
continue;
}
let model_info =
Self::construct_model_info_for_custom_alias(alias, custom, &remote_models);
let mut preset = ModelPreset::from(model_info);
preset.show_in_picker = true;
custom_presets.push(preset);
existing_models.insert(alias.to_string());
}
let chatgpt_mode = matches!(self.auth_manager.auth_mode(), Some(AuthMode::Chatgpt));
presets = ModelPreset::filter_by_auth(presets, chatgpt_mode);
custom_presets = ModelPreset::filter_by_auth(custom_presets, chatgpt_mode);
ModelPreset::mark_default_by_picker_visibility(&mut presets);
if !presets.iter().any(|preset| preset.is_default) {
ModelPreset::mark_default_by_picker_visibility(&mut custom_presets);
}
custom_presets.extend(presets);
presets = custom_presets;
presets
}
@@ -546,7 +634,8 @@ impl ModelsManager {
Self::new_with_provider(
codex_home,
auth_manager,
/*model_catalog*/ None,
None,
HashMap::new(),
CollaborationModesConfig::default(),
provider,
)
@@ -578,7 +667,12 @@ impl ModelsManager {
} else {
&[]
};
Self::construct_model_info_from_candidates(model, candidates, config)
Self::construct_model_info_from_candidates_with_custom(
model,
candidates,
config,
config.custom_model_alias(model),
)
}
}
+216 -28
View File
@@ -145,7 +145,8 @@ async fn get_model_info_tracks_fallback_usage() {
let manager = ModelsManager::new(
codex_home.path().to_path_buf(),
auth_manager,
/*model_catalog*/ None,
None,
HashMap::new(),
CollaborationModesConfig::default(),
);
let known_slug = manager
@@ -175,7 +176,7 @@ async fn get_model_info_uses_custom_catalog() {
.build()
.await
.expect("load default test config");
let mut overlay = remote_model("gpt-overlay", "Overlay", /*priority*/ 0);
let mut overlay = remote_model("gpt-overlay", "Overlay", 0);
overlay.supports_image_detail_original = true;
let auth_manager = AuthManager::from_auth_for_testing(CodexAuth::from_api_key("Test API Key"));
@@ -185,6 +186,7 @@ async fn get_model_info_uses_custom_catalog() {
Some(ModelsResponse {
models: vec![overlay],
}),
HashMap::new(),
CollaborationModesConfig::default(),
);
@@ -208,7 +210,7 @@ async fn get_model_info_matches_namespaced_suffix() {
.build()
.await
.expect("load default test config");
let mut remote = remote_model("gpt-image", "Image", /*priority*/ 0);
let mut remote = remote_model("gpt-image", "Image", 0);
remote.supports_image_detail_original = true;
let auth_manager = AuthManager::from_auth_for_testing(CodexAuth::from_api_key("Test API Key"));
let manager = ModelsManager::new(
@@ -217,6 +219,7 @@ async fn get_model_info_matches_namespaced_suffix() {
Some(ModelsResponse {
models: vec![remote],
}),
HashMap::new(),
CollaborationModesConfig::default(),
);
let namespaced_model = "custom/gpt-image".to_string();
@@ -240,7 +243,8 @@ async fn get_model_info_rejects_multi_segment_namespace_suffix_matching() {
let manager = ModelsManager::new(
codex_home.path().to_path_buf(),
auth_manager,
/*model_catalog*/ None,
None,
HashMap::new(),
CollaborationModesConfig::default(),
);
let known_slug = manager
@@ -262,8 +266,8 @@ async fn get_model_info_rejects_multi_segment_namespace_suffix_matching() {
async fn refresh_available_models_sorts_by_priority() {
let server = MockServer::start().await;
let remote_models = vec![
remote_model("priority-low", "Low", /*priority*/ 1),
remote_model("priority-high", "High", /*priority*/ 0),
remote_model("priority-low", "Low", 1),
remote_model("priority-high", "High", 0),
];
let models_mock = mount_models_once(
&server,
@@ -313,7 +317,7 @@ async fn refresh_available_models_sorts_by_priority() {
#[tokio::test]
async fn refresh_available_models_uses_cache_when_fresh() {
let server = MockServer::start().await;
let remote_models = vec![remote_model("cached", "Cached", /*priority*/ 5)];
let remote_models = vec![remote_model("cached", "Cached", 5)];
let models_mock = mount_models_once(
&server,
ModelsResponse {
@@ -354,7 +358,7 @@ async fn refresh_available_models_uses_cache_when_fresh() {
#[tokio::test]
async fn refresh_available_models_refetches_when_cache_stale() {
let server = MockServer::start().await;
let initial_models = vec![remote_model("stale", "Stale", /*priority*/ 1)];
let initial_models = vec![remote_model("stale", "Stale", 1)];
let initial_mock = mount_models_once(
&server,
ModelsResponse {
@@ -387,7 +391,7 @@ async fn refresh_available_models_refetches_when_cache_stale() {
.await
.expect("cache manipulation succeeds");
let updated_models = vec![remote_model("fresh", "Fresh", /*priority*/ 9)];
let updated_models = vec![remote_model("fresh", "Fresh", 9)];
server.reset().await;
let refreshed_mock = mount_models_once(
&server,
@@ -417,7 +421,7 @@ async fn refresh_available_models_refetches_when_cache_stale() {
#[tokio::test]
async fn refresh_available_models_refetches_when_version_mismatch() {
let server = MockServer::start().await;
let initial_models = vec![remote_model("old", "Old", /*priority*/ 1)];
let initial_models = vec![remote_model("old", "Old", 1)];
let initial_mock = mount_models_once(
&server,
ModelsResponse {
@@ -450,7 +454,7 @@ async fn refresh_available_models_refetches_when_version_mismatch() {
.await
.expect("cache mutation succeeds");
let updated_models = vec![remote_model("new", "New", /*priority*/ 2)];
let updated_models = vec![remote_model("new", "New", 2)];
server.reset().await;
let refreshed_mock = mount_models_once(
&server,
@@ -480,11 +484,7 @@ async fn refresh_available_models_refetches_when_version_mismatch() {
#[tokio::test]
async fn refresh_available_models_drops_removed_remote_models() {
let server = MockServer::start().await;
let initial_models = vec![remote_model(
"remote-old",
"Remote Old",
/*priority*/ 1,
)];
let initial_models = vec![remote_model("remote-old", "Remote Old", 1)];
let initial_mock = mount_models_once(
&server,
ModelsResponse {
@@ -510,11 +510,7 @@ async fn refresh_available_models_drops_removed_remote_models() {
.expect("initial refresh succeeds");
server.reset().await;
let refreshed_models = vec![remote_model(
"remote-new",
"Remote New",
/*priority*/ 1,
)];
let refreshed_models = vec![remote_model("remote-new", "Remote New", 1)];
let refreshed_mock = mount_models_once(
&server,
ModelsResponse {
@@ -558,7 +554,7 @@ async fn refresh_available_models_skips_network_without_chatgpt_auth() {
let models_mock = mount_models_once(
&server,
ModelsResponse {
models: vec![remote_model(dynamic_slug, "No Auth", /*priority*/ 1)],
models: vec![remote_model(dynamic_slug, "No Auth", 1)],
},
)
.await;
@@ -566,7 +562,7 @@ async fn refresh_available_models_skips_network_without_chatgpt_auth() {
let codex_home = tempdir().expect("temp dir");
let auth_manager = Arc::new(AuthManager::new(
codex_home.path().to_path_buf(),
/*enable_codex_api_key_env*/ false,
false,
AuthCredentialsStoreMode::File,
));
let provider = provider_for(server.uri());
@@ -629,7 +625,7 @@ fn models_request_telemetry_emits_auth_env_feedback_tags_on_failure() {
.unwrap(),
);
telemetry.on_request(
/*attempt*/ 1,
1,
Some(StatusCode::UNAUTHORIZED),
Some(&TransportError::Http {
status: StatusCode::UNAUTHORIZED,
@@ -703,10 +699,8 @@ fn build_available_models_picks_default_after_hiding_hidden_models() {
provider,
);
let hidden_model =
remote_model_with_visibility("hidden", "Hidden", /*priority*/ 0, "hide");
let visible_model =
remote_model_with_visibility("visible", "Visible", /*priority*/ 1, "list");
let hidden_model = remote_model_with_visibility("hidden", "Hidden", 0, "hide");
let visible_model = remote_model_with_visibility("visible", "Visible", 1, "list");
let expected_hidden = ModelPreset::from(hidden_model.clone());
let mut expected_visible = ModelPreset::from(visible_model.clone());
@@ -717,6 +711,200 @@ fn build_available_models_picks_default_after_hiding_hidden_models() {
assert_eq!(available, vec![expected_hidden, expected_visible]);
}
#[tokio::test]
async fn get_model_info_uses_custom_alias_metadata_and_request_model() {
let codex_home = tempdir().expect("temp dir");
let mut config = ConfigBuilder::default()
.codex_home(codex_home.path().to_path_buf())
.build()
.await
.expect("load default test config");
let alias = "gpt-5.4 1m".to_string();
let custom_model = CustomModelConfig {
model: "gpt-5.4".to_string(),
model_context_window: Some(1_000_000),
model_auto_compact_token_limit: Some(800_000),
};
config
.custom_models
.insert(alias.clone(), custom_model.clone());
let auth_manager = AuthManager::from_auth_for_testing(CodexAuth::from_api_key("Test API Key"));
let manager = ModelsManager::new(
codex_home.path().to_path_buf(),
auth_manager,
Some(ModelsResponse {
models: vec![remote_model("gpt-5.4", "GPT 5.4", 0)],
}),
HashMap::from([(alias.clone(), custom_model)]),
CollaborationModesConfig::default(),
);
let model_info = manager.get_model_info(&alias, &config).await;
assert_eq!(model_info.slug, alias);
assert_eq!(model_info.request_model.as_deref(), Some("gpt-5.4"));
assert_eq!(model_info.context_window, Some(1_000_000));
assert_eq!(model_info.auto_compact_token_limit, Some(800_000));
}
#[tokio::test]
async fn get_model_info_prefers_custom_alias_context_over_global_config() {
let codex_home = tempdir().expect("temp dir");
let mut config = ConfigBuilder::default()
.codex_home(codex_home.path().to_path_buf())
.build()
.await
.expect("load default test config");
config.model_context_window = Some(250_000);
config.model_auto_compact_token_limit = Some(200_000);
let alias = "gpt-5.4 1m".to_string();
let custom_model = CustomModelConfig {
model: "gpt-5.4".to_string(),
model_context_window: Some(1_000_000),
model_auto_compact_token_limit: Some(800_000),
};
config
.custom_models
.insert(alias.clone(), custom_model.clone());
let auth_manager = AuthManager::from_auth_for_testing(CodexAuth::from_api_key("Test API Key"));
let manager = ModelsManager::new(
codex_home.path().to_path_buf(),
auth_manager,
Some(ModelsResponse {
models: vec![remote_model("gpt-5.4", "GPT 5.4", 0)],
}),
HashMap::from([(alias.clone(), custom_model)]),
CollaborationModesConfig::default(),
);
let model_info = manager.get_model_info(&alias, &config).await;
assert_eq!(model_info.context_window, Some(1_000_000));
assert_eq!(model_info.auto_compact_token_limit, Some(800_000));
}
#[tokio::test]
async fn get_model_info_prefers_active_config_alias_over_startup_snapshot() {
let codex_home = tempdir().expect("temp dir");
let mut config = ConfigBuilder::default()
.codex_home(codex_home.path().to_path_buf())
.build()
.await
.expect("load default test config");
let alias = "gpt-5.4 1m".to_string();
config.custom_models.insert(
alias.clone(),
CustomModelConfig {
model: "gpt-5.4-updated".to_string(),
model_context_window: Some(1_000_000),
model_auto_compact_token_limit: Some(900_000),
},
);
let auth_manager = AuthManager::from_auth_for_testing(CodexAuth::from_api_key("Test API Key"));
let manager = ModelsManager::new(
codex_home.path().to_path_buf(),
auth_manager,
Some(ModelsResponse {
models: vec![
remote_model("gpt-5.4", "GPT 5.4", 0),
remote_model("gpt-5.4-updated", "GPT 5.4 Updated", 1),
],
}),
HashMap::from([(
alias.clone(),
CustomModelConfig {
model: "gpt-5.4".to_string(),
model_context_window: Some(500_000),
model_auto_compact_token_limit: Some(400_000),
},
)]),
CollaborationModesConfig::default(),
);
let model_info = manager.get_model_info(&alias, &config).await;
assert_eq!(model_info.slug, alias);
assert_eq!(model_info.request_model.as_deref(), Some("gpt-5.4-updated"));
assert_eq!(model_info.context_window, Some(1_000_000));
assert_eq!(model_info.auto_compact_token_limit, Some(900_000));
}
#[test]
fn build_available_models_includes_custom_aliases() {
let codex_home = tempdir().expect("temp dir");
let auth_manager = AuthManager::from_auth_for_testing(CodexAuth::from_api_key("Test API Key"));
let provider = provider_for("http://example.test".to_string());
let mut manager = ModelsManager::with_provider_for_tests(
codex_home.path().to_path_buf(),
auth_manager,
provider,
);
manager.custom_models = HashMap::from([(
"gpt-5.4 1m".to_string(),
CustomModelConfig {
model: "gpt-5.4".to_string(),
model_context_window: Some(1_000_000),
model_auto_compact_token_limit: Some(800_000),
},
)]);
let available = manager.build_available_models(vec![remote_model("gpt-5.4", "GPT 5.4", 0)]);
let alias = available
.iter()
.find(|preset| preset.model == "gpt-5.4 1m")
.expect("custom alias should be listed");
assert!(alias.show_in_picker);
assert_eq!(alias.display_name, "gpt-5.4 1m");
}
#[test]
fn build_available_models_lists_custom_aliases_before_remote_models() {
let codex_home = tempdir().expect("temp dir");
let auth_manager = AuthManager::from_auth_for_testing(CodexAuth::from_api_key("Test API Key"));
let provider = provider_for("http://example.test".to_string());
let mut manager = ModelsManager::with_provider_for_tests(
codex_home.path().to_path_buf(),
auth_manager,
provider,
);
manager.custom_models = HashMap::from([(
"gpt-5.4 1m".to_string(),
CustomModelConfig {
model: "gpt-5.4".to_string(),
model_context_window: Some(1_000_000),
model_auto_compact_token_limit: Some(800_000),
},
)]);
let available = manager.build_available_models(vec![
remote_model("gpt-5.4", "GPT 5.4", 0),
remote_model("gpt-5.3", "GPT 5.3", 1),
]);
assert_eq!(
available
.iter()
.map(|preset| preset.model.as_str())
.collect::<Vec<_>>(),
vec!["gpt-5.4 1m", "gpt-5.4", "gpt-5.3"]
);
assert_eq!(
available
.iter()
.find(|preset| preset.is_default)
.map(|preset| preset.model.as_str()),
Some("gpt-5.4")
);
}
#[test]
fn bundled_models_json_roundtrips() {
let file_contents = include_str!("../../models.json");
@@ -62,6 +62,7 @@ pub(crate) fn model_info_from_slug(slug: &str) -> ModelInfo {
warn!("Unknown model {slug} is used. This will use fallback model metadata.");
ModelInfo {
slug: slug.to_string(),
request_model: None,
display_name: slug.to_string(),
description: None,
default_reasoning_level: None,