Add remote models feature flag (#7648)

# External (non-OpenAI) Pull Request Requirements

Before opening this Pull Request, please read the dedicated
"Contributing" markdown file or your PR may be closed:
https://github.com/openai/codex/blob/main/docs/contributing.md

If your PR conforms to our contribution guidelines, replace this text
with a detailed and high quality description of your changes.

Include a link to a bug report or enhancement request.

codex-rs/core/src/codex.rs

@@ -1470,6 +1470,16 @@ async fn submission_loop(sess: Arc<Session>, config: Arc<Config>, rx_sub: Receiv
     let mut previous_context: Option<Arc<TurnContext>> =
         Some(sess.new_turn(SessionSettingsUpdate::default()).await);
 
+    if config.features.enabled(Feature::RemoteModels)
+        && let Err(err) = sess
+            .services
+            .models_manager
+            .refresh_available_models(&config.model_provider)
+            .await
+    {
+        error!("failed to refresh available models: {err}");
+    }
+
     // To break out of this loop, send Op::Shutdown.
     while let Ok(sub) = rx_sub.recv().await {
         debug!(?sub, "Submission");

codex-rs/core/src/features.rs

@@ -54,6 +54,8 @@ pub enum Feature {
     WindowsSandbox,
     /// Remote compaction enabled (only for ChatGPT auth)
     RemoteCompaction,
+    /// Refresh remote models and emit AppReady once the list is available.
+    RemoteModels,
     /// Allow model to call multiple tools in parallel (only for models supporting it).
     ParallelToolCalls,
     /// Experimental skills injection (CLI flag-driven).
@@ -333,6 +335,12 @@ pub const FEATURES: &[FeatureSpec] = &[
         stage: Stage::Experimental,
         default_enabled: true,
     },
+    FeatureSpec {
+        id: Feature::RemoteModels,
+        key: "remote_models",
+        stage: Stage::Experimental,
+        default_enabled: false,
+    },
     FeatureSpec {
         id: Feature::ParallelToolCalls,
         key: "parallel",

codex-rs/core/src/openai_models/model_family.rs

@@ -291,6 +291,7 @@ mod tests {
     use super::*;
     use codex_protocol::openai_models::ClientVersion;
     use codex_protocol::openai_models::ModelVisibility;
+    use codex_protocol::openai_models::ReasoningEffortPreset;
 
     fn remote(slug: &str, effort: ReasoningEffort, shell: ConfigShellToolType) -> ModelInfo {
         ModelInfo {
@@ -298,12 +299,16 @@ mod tests {
             display_name: slug.to_string(),
             description: Some(format!("{slug} desc")),
             default_reasoning_level: effort,
-            supported_reasoning_levels: vec![effort],
+            supported_reasoning_levels: vec![ReasoningEffortPreset {
+                effort,
+                description: effort.to_string(),
+            }],
             shell_type: shell,
             visibility: ModelVisibility::List,
             minimal_client_version: ClientVersion(0, 1, 0),
             supported_in_api: true,
             priority: 1,
+            upgrade: None,
         }
     }
 

codex-rs/core/src/openai_models/models_manager.rs

@@ -36,7 +36,6 @@ impl ModelsManager {
         }
     }
 
-    // do not use this function yet. It's work in progress.
     pub async fn refresh_available_models(
         &self,
         provider: &ModelProviderInfo,
@@ -47,16 +46,21 @@ impl ModelsManager {
         let transport = ReqwestTransport::new(build_reqwest_client());
         let client = ModelsClient::new(transport, api_provider, api_auth);
 
+        let mut client_version = env!("CARGO_PKG_VERSION");
+        if client_version == "0.0.0" {
+            client_version = "99.99.99";
+        }
         let response = client
-            .list_models(env!("CARGO_PKG_VERSION"), HeaderMap::new())
+            .list_models(client_version, HeaderMap::new())
             .await
             .map_err(map_api_error)?;
 
         let models = response.models;
         *self.remote_models.write().await = models.clone();
+        let available_models = self.build_available_models().await;
         {
             let mut available_models_guard = self.available_models.write().await;
-            *available_models_guard = self.build_available_models().await;
+            *available_models_guard = available_models;
         }
         Ok(models)
     }
@@ -75,8 +79,11 @@ impl ModelsManager {
     async fn build_available_models(&self) -> Vec<ModelPreset> {
         let mut available_models = self.remote_models.read().await.clone();
         available_models.sort_by(|a, b| b.priority.cmp(&a.priority));
-        let mut model_presets: Vec<ModelPreset> =
-            available_models.into_iter().map(Into::into).collect();
+        let mut model_presets: Vec<ModelPreset> = available_models
+            .into_iter()
+            .map(Into::into)
+            .filter(|preset: &ModelPreset| preset.show_in_picker)
+            .collect();
         if let Some(default) = model_presets.first_mut() {
             default.is_default = true;
         }
@@ -103,12 +110,13 @@ mod tests {
             "display_name": display,
             "description": format!("{display} desc"),
             "default_reasoning_level": "medium",
-            "supported_reasoning_levels": ["low", "medium"],
+            "supported_reasoning_levels": [{"effort": "low", "description": "low"}, {"effort": "medium", "description": "medium"}],
             "shell_type": "shell_command",
             "visibility": "list",
             "minimal_client_version": [0, 1, 0],
             "supported_in_api": true,
-            "priority": priority
+            "priority": priority,
+            "upgrade": null,
         }))
         .expect("valid model")
     }