Update Model Info (#7853)

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

@@ -1,12 +1,12 @@
 use codex_protocol::config_types::Verbosity;
+use codex_protocol::openai_models::ApplyPatchToolType;
+use codex_protocol::openai_models::ConfigShellToolType;
 use codex_protocol::openai_models::ModelInfo;
 use codex_protocol::openai_models::ReasoningEffort;
+use codex_protocol::openai_models::ReasoningSummaryFormat;
 
 use crate::config::Config;
-use crate::config::types::ReasoningSummaryFormat;
-use crate::tools::handlers::apply_patch::ApplyPatchToolType;
 use crate::truncate::TruncationPolicy;
-use codex_protocol::openai_models::ConfigShellToolType;
 
 /// The `instructions` field in the payload sent to a model should always start
 /// with this content.
@@ -101,14 +101,53 @@ impl ModelFamily {
     pub fn with_remote_overrides(mut self, remote_models: Vec<ModelInfo>) -> Self {
         for model in remote_models {
             if model.slug == self.slug {
-                self.default_reasoning_effort = Some(model.default_reasoning_level);
-                self.shell_type = model.shell_type;
-                self.base_instructions = model.base_instructions.unwrap_or(self.base_instructions);
+                self.apply_remote_overrides(model);
             }
         }
         self
     }
 
+    fn apply_remote_overrides(&mut self, model: ModelInfo) {
+        let ModelInfo {
+            slug: _,
+            display_name: _,
+            description: _,
+            default_reasoning_level,
+            supported_reasoning_levels: _,
+            shell_type,
+            visibility: _,
+            minimal_client_version: _,
+            supported_in_api: _,
+            priority: _,
+            upgrade: _,
+            base_instructions,
+            supports_reasoning_summaries,
+            support_verbosity,
+            default_verbosity,
+            apply_patch_tool_type,
+            truncation_policy,
+            supports_parallel_tool_calls,
+            context_window,
+            reasoning_summary_format,
+            experimental_supported_tools,
+        } = model;
+
+        self.default_reasoning_effort = Some(default_reasoning_level);
+        self.shell_type = shell_type;
+        if let Some(base) = base_instructions {
+            self.base_instructions = base;
+        }
+        self.supports_reasoning_summaries = supports_reasoning_summaries;
+        self.support_verbosity = support_verbosity;
+        self.default_verbosity = default_verbosity;
+        self.apply_patch_tool_type = apply_patch_tool_type;
+        self.truncation_policy = truncation_policy.into();
+        self.supports_parallel_tool_calls = supports_parallel_tool_calls;
+        self.context_window = context_window;
+        self.reasoning_summary_format = reasoning_summary_format;
+        self.experimental_supported_tools = experimental_supported_tools;
+    }
+
     pub fn auto_compact_token_limit(&self) -> Option<i64> {
         self.auto_compact_token_limit
             .or(self.context_window.map(Self::default_auto_compact_limit))
@@ -356,6 +395,7 @@ mod tests {
     use codex_protocol::openai_models::ClientVersion;
     use codex_protocol::openai_models::ModelVisibility;
     use codex_protocol::openai_models::ReasoningEffortPreset;
+    use codex_protocol::openai_models::TruncationPolicyConfig;
 
     fn remote(slug: &str, effort: ReasoningEffort, shell: ConfigShellToolType) -> ModelInfo {
         ModelInfo {
@@ -374,6 +414,15 @@ mod tests {
             priority: 1,
             upgrade: None,
             base_instructions: None,
+            supports_reasoning_summaries: false,
+            support_verbosity: false,
+            default_verbosity: None,
+            apply_patch_tool_type: None,
+            truncation_policy: TruncationPolicyConfig::bytes(10_000),
+            supports_parallel_tool_calls: false,
+            context_window: None,
+            reasoning_summary_format: ReasoningSummaryFormat::None,
+            experimental_supported_tools: Vec::new(),
         }
     }
 
@@ -422,4 +471,73 @@ mod tests {
         );
         assert_eq!(updated.shell_type, family.shell_type);
     }
+
+    #[test]
+    fn remote_overrides_apply_extended_metadata() {
+        let family = model_family!(
+            "gpt-5.1",
+            "gpt-5.1",
+            supports_reasoning_summaries: false,
+            support_verbosity: false,
+            default_verbosity: None,
+            apply_patch_tool_type: Some(ApplyPatchToolType::Function),
+            supports_parallel_tool_calls: false,
+            experimental_supported_tools: vec!["local".to_string()],
+            truncation_policy: TruncationPolicy::Bytes(10_000),
+            context_window: Some(100),
+            reasoning_summary_format: ReasoningSummaryFormat::None,
+        );
+
+        let updated = family.with_remote_overrides(vec![ModelInfo {
+            slug: "gpt-5.1".to_string(),
+            display_name: "gpt-5.1".to_string(),
+            description: Some("desc".to_string()),
+            default_reasoning_level: ReasoningEffort::High,
+            supported_reasoning_levels: vec![ReasoningEffortPreset {
+                effort: ReasoningEffort::High,
+                description: "High".to_string(),
+            }],
+            shell_type: ConfigShellToolType::ShellCommand,
+            visibility: ModelVisibility::List,
+            minimal_client_version: ClientVersion(0, 1, 0),
+            supported_in_api: true,
+            priority: 10,
+            upgrade: None,
+            base_instructions: Some("Remote instructions".to_string()),
+            supports_reasoning_summaries: true,
+            support_verbosity: true,
+            default_verbosity: Some(Verbosity::High),
+            apply_patch_tool_type: Some(ApplyPatchToolType::Freeform),
+            truncation_policy: TruncationPolicyConfig::tokens(2_000),
+            supports_parallel_tool_calls: true,
+            context_window: Some(400_000),
+            reasoning_summary_format: ReasoningSummaryFormat::Experimental,
+            experimental_supported_tools: vec!["alpha".to_string(), "beta".to_string()],
+        }]);
+
+        assert_eq!(
+            updated.default_reasoning_effort,
+            Some(ReasoningEffort::High)
+        );
+        assert!(updated.supports_reasoning_summaries);
+        assert!(updated.support_verbosity);
+        assert_eq!(updated.default_verbosity, Some(Verbosity::High));
+        assert_eq!(updated.shell_type, ConfigShellToolType::ShellCommand);
+        assert_eq!(
+            updated.apply_patch_tool_type,
+            Some(ApplyPatchToolType::Freeform)
+        );
+        assert_eq!(updated.truncation_policy, TruncationPolicy::Tokens(2_000));
+        assert!(updated.supports_parallel_tool_calls);
+        assert_eq!(updated.context_window, Some(400_000));
+        assert_eq!(
+            updated.reasoning_summary_format,
+            ReasoningSummaryFormat::Experimental
+        );
+        assert_eq!(
+            updated.experimental_supported_tools,
+            vec!["alpha".to_string(), "beta".to_string()]
+        );
+        assert_eq!(updated.base_instructions, "Remote instructions");
+    }
 }

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

@@ -206,7 +206,7 @@ impl ModelsManager {
     /// Convert remote model metadata into picker-ready presets, marking defaults.
     async fn build_available_models(&self) {
         let mut available_models = self.remote_models.read().await.clone();
-        available_models.sort_by(|a, b| b.priority.cmp(&a.priority));
+        available_models.sort_by(|a, b| a.priority.cmp(&b.priority));
         let mut model_presets: Vec<ModelPreset> = available_models
             .into_iter()
             .map(Into::into)
@@ -279,6 +279,15 @@ mod tests {
             "priority": priority,
             "upgrade": null,
             "base_instructions": null,
+            "supports_reasoning_summaries": false,
+            "support_verbosity": false,
+            "default_verbosity": null,
+            "apply_patch_tool_type": null,
+            "truncation_policy": {"mode": "bytes", "limit": 10_000},
+            "supports_parallel_tool_calls": false,
+            "context_window": null,
+            "reasoning_summary_format": "none",
+            "experimental_supported_tools": [],
         }))
         .expect("valid model")
     }
@@ -306,7 +315,7 @@ mod tests {
         let server = MockServer::start().await;
         let remote_models = vec![
             remote_model("priority-low", "Low", 1),
-            remote_model("priority-high", "High", 10),
+            remote_model("priority-high", "High", 0),
         ];
         let models_mock = mount_models_once(
             &server,