fix: route model picker by provider binding

Author: wangtsiao

crates/cli/src/agent_command.rs

@@ -70,8 +70,12 @@ pub(crate) async fn run_agent(
             Some(binding.model_name.clone())
         }
     });
+    let model_binding_id = active_model_binding
+        .as_ref()
+        .map(|binding| binding.binding_id.clone());
     let model = active_model_binding
-        .map(|binding| binding.model_slug)
+        .as_ref()
+        .map(|binding| binding.model_slug.clone())
         .unwrap_or(model);
 
     tracing::info!("starting interactive tui");
@@ -81,6 +85,7 @@ pub(crate) async fn run_agent(
             session_id: initial_session_id,
             model,
             request_model,
+            model_binding_id,
             provider: wire_api,
             thinking_selection: model_thinking_selection,
             permission_preset,
@@ -143,9 +148,9 @@ fn saved_model_entries(app_config: &AppConfig) -> Vec<SavedModelEntry> {
     let stored_config = &app_config.provider;
     let mut entries = stored_config
         .model_bindings
-        .values()
-        .filter(|binding| binding.enabled)
-        .filter_map(|binding| {
+        .iter()
+        .filter(|(_, binding)| binding.enabled)
+        .filter_map(|(binding_id, binding)| {
             let provider = stored_config.providers.get(&binding.provider)?;
             let request_model = if binding.model_name == binding.model_slug {
                 None
@@ -156,46 +161,62 @@ fn saved_model_entries(app_config: &AppConfig) -> Vec<SavedModelEntry> {
                 .display_name
                 .clone()
                 .or_else(|| request_model.clone());
+            let provider_name = provider
+                .name
+                .trim()
+                .is_empty()
+                .then(|| binding.provider.clone())
+                .unwrap_or_else(|| provider.name.clone());
             Some(SavedModelEntry {
+                binding_id: Some(binding_id.clone()),
                 model: binding.model_slug.clone(),
                 request_model,
                 display_name,
+                provider_id: Some(binding.provider.clone()),
+                provider_name: Some(provider_name),
                 wire_api: binding.invocation_method,
                 base_url: provider.base_url.clone(),
                 api_key: None,
             })
         })
         .collect::<Vec<_>>();
 
-    entries.extend(
-        stored_config
-            .model_providers
-            .values()
-            .flat_map(|provider_config| {
-                // Older config entries may not have persisted `wire_api`; keep them
-                // on the historical OpenAI-compatible chat-completions default.
-                let wire_api = provider_config
-                    .wire_api
-                    .unwrap_or(ProviderWireApi::OpenAIChatCompletions);
-                provider_config
-                    .models
-                    .iter()
-                    .map(move |model| SavedModelEntry {
-                        model: model.model.clone(),
-                        request_model: None,
-                        display_name: None,
-                        wire_api,
-                        base_url: model
-                            .base_url
-                            .clone()
-                            .or_else(|| provider_config.base_url.clone()),
-                        api_key: model
-                            .api_key
-                            .clone()
-                            .or_else(|| provider_config.api_key.clone()),
-                    })
-            }),
-    );
+    entries.extend(stored_config.model_providers.iter().flat_map(
+        |(provider_id, provider_config)| {
+            // Older config entries may not have persisted `wire_api`; keep them
+            // on the historical OpenAI-compatible chat-completions default.
+            let wire_api = provider_config
+                .wire_api
+                .unwrap_or(ProviderWireApi::OpenAIChatCompletions);
+            let provider_name = provider_config
+                .name
+                .as_deref()
+                .map(str::trim)
+                .filter(|name| !name.is_empty())
+                .map(ToOwned::to_owned)
+                .unwrap_or_else(|| provider_id.clone());
+            provider_config
+                .models
+                .iter()
+                .map(move |model| SavedModelEntry {
+                    binding_id: None,
+                    model: model.model.clone(),
+                    request_model: None,
+                    display_name: None,
+                    provider_id: Some(provider_id.clone()),
+                    provider_name: Some(provider_name.clone()),
+                    wire_api,
+                    base_url: model
+                        .base_url
+                        .clone()
+                        .or_else(|| provider_config.base_url.clone()),
+                    api_key: model
+                        .api_key
+                        .clone()
+                        .or_else(|| provider_config.api_key.clone()),
+                })
+        },
+    ));
     entries
 }
 
@@ -421,17 +442,23 @@ mod tests {
             saved_model_entries(&app_config),
             vec![
                 SavedModelEntry {
+                    binding_id: Some("openai".to_string()),
                     model: "provider-defaults".to_string(),
                     request_model: None,
                     display_name: None,
+                    provider_id: Some("openai".to_string()),
+                    provider_name: Some("openai".to_string()),
                     wire_api: ProviderWireApi::OpenAIResponses,
                     base_url: Some("https://provider.example".to_string()),
                     api_key: None,
                 },
                 SavedModelEntry {
+                    binding_id: None,
                     model: "model-overrides".to_string(),
                     request_model: None,
                     display_name: None,
+                    provider_id: Some("legacy".to_string()),
+                    provider_name: Some("legacy".to_string()),
                     wire_api: ProviderWireApi::OpenAIResponses,
                     base_url: Some("https://model.example".to_string()),
                     api_key: Some("model-key".to_string()),
@@ -469,9 +496,12 @@ mod tests {
         assert_eq!(
             saved_model_entries(&app_config),
             vec![SavedModelEntry {
+                binding_id: Some("deepseek".to_string()),
                 model: "deepseek-v4-flash".to_string(),
                 request_model: Some("DeepSeek-V4-Flash".to_string()),
                 display_name: Some("DeepSeek-V4-Flash".to_string()),
+                provider_id: Some("deepseek".to_string()),
+                provider_name: Some("deepseek".to_string()),
                 wire_api: ProviderWireApi::OpenAIChatCompletions,
                 base_url: Some("https://api.deepseek.com".to_string()),
                 api_key: None,
@@ -498,9 +528,12 @@ mod tests {
         assert_eq!(
             saved_model_entries(&app_config),
             vec![SavedModelEntry {
+                binding_id: None,
                 model: "default-wire-api".to_string(),
                 request_model: None,
                 display_name: None,
+                provider_id: Some("openai".to_string()),
+                provider_name: Some("openai".to_string()),
                 wire_api: ProviderWireApi::OpenAIChatCompletions,
                 base_url: None,
                 api_key: None,

crates/config/src/provider.rs

@@ -169,6 +169,38 @@ model_name = "gpt-5.4"
         assert_eq!(binding, expected_resolved_binding("two"));
     }
 
+    #[test]
+    fn enabled_model_binding_resolves_requested_binding_id_before_slug() {
+        let mut config = provider_config_with_bindings();
+        config.model_bindings.insert(
+            "catalog-two".to_string(),
+            ModelBindingConfig {
+                enabled: true,
+                model_slug: "catalog-one".to_string(),
+                provider: "direct".to_string(),
+                model_name: "direct/one".to_string(),
+                invocation_method: ProviderWireApi::OpenAIChatCompletions,
+                ..ModelBindingConfig::default()
+            },
+        );
+
+        let binding =
+            resolve_enabled_model_binding(&config, Some("catalog-two")).expect("resolve binding");
+
+        assert_eq!(
+            binding,
+            ResolvedModelBinding {
+                binding_id: "catalog-two".to_string(),
+                model_slug: "catalog-one".to_string(),
+                model_name: "direct/one".to_string(),
+                provider_id: "direct".to_string(),
+                invocation_method: ProviderWireApi::OpenAIChatCompletions,
+                default_reasoning_effort: None,
+                enabled: true,
+            }
+        );
+    }
+
     #[test]
     fn enabled_model_binding_uses_default_binding_without_requested_model() {
         let config = provider_config_with_bindings();

crates/config/src/provider/resolve.rs

@@ -154,6 +154,14 @@ pub fn resolve_model_binding(
     // a configured-but-disabled binding visible so the caller can report
     // "binding is disabled" instead of silently selecting another model.
     if let Some(requested_model) = requested_model {
+        if let Some((binding_id, binding)) = config
+            .model_bindings
+            .iter()
+            .find(|(binding_id, _)| binding_id.as_str() == requested_model)
+        {
+            return Some(ResolvedModelBinding::from_config(binding_id, binding));
+        }
+
         return config
             .model_bindings
             .iter()
@@ -195,9 +203,18 @@ pub fn resolve_enabled_model_binding(
     requested_model: Option<&str>,
 ) -> Option<ResolvedModelBinding> {
     // Runtime turn selection only uses enabled bindings. A user-facing model
-    // override may name either the local catalog slug or the provider wire name:
-    // e.g. `deepseek-v4-pro` or `deepseek/deepseek-v4-pro`.
+    // override may name the binding id, the local catalog slug, or the provider
+    // wire name: e.g. `deepseek-main`, `deepseek-v4-pro`, or
+    // `deepseek/deepseek-v4-pro`.
     if let Some(requested_model) = requested_model {
+        if let Some((binding_id, binding)) = config
+            .model_bindings
+            .iter()
+            .find(|(binding_id, binding)| binding.enabled && binding_id.as_str() == requested_model)
+        {
+            return Some(ResolvedModelBinding::from_config(binding_id, binding));
+        }
+
         return config
             .model_bindings
             .iter()

crates/tui/src/app.rs

@@ -34,6 +34,8 @@ pub struct InitialTuiSession {
     pub model: String,
     /// Optional provider-specific model name used for requests when it differs from `model`.
     pub request_model: Option<String>,
+    /// Active model binding id when startup resolved one from `[model_bindings]`.
+    pub model_binding_id: Option<String>,
     /// Provider family used for the initial runtime connection and picker fallback.
     pub provider: ProviderWireApi,
     /// Initial thinking selection restored from persisted config.

crates/tui/src/bottom_pane/mod.rs

@@ -20,6 +20,7 @@ use ratatui::text::Line;
 use ratatui::text::Span;
 use ratatui::widgets::Paragraph;
 use ratatui::widgets::Widget;
+use unicode_width::UnicodeWidthStr;
 
 mod approval_overlay;
 pub(crate) mod bottom_pane_view;
@@ -195,9 +196,10 @@ pub(crate) enum InputResult {
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) struct ModelPickerEntry {
-    pub(crate) slug: String,
+    pub(crate) selection_value: String,
     pub(crate) display_name: String,
     pub(crate) description: Option<String>,
+    pub(crate) right_hint: Option<String>,
     pub(crate) is_current: bool,
 }
 
@@ -1038,11 +1040,11 @@ impl ModelPickerView {
         self.selected_model = self
             .entries
             .get(self.selection)
-            .map(|entry| entry.slug.clone());
+            .map(|entry| entry.selection_value.clone());
         self.complete = true;
     }
 
-    fn render_lines(&self) -> Vec<Line<'static>> {
+    fn render_lines(&self, width: u16) -> Vec<Line<'static>> {
         let mut lines: Vec<Line<'static>> = Vec::new();
         for (index, entry) in self.entries.iter().enumerate() {
             let is_selected = index == self.selection;
@@ -1058,17 +1060,33 @@ impl ModelPickerView {
             } else {
                 Style::default()
             };
-            let mut title = Line::from(vec![
+            let label_style = if is_selected {
+                Style::default().fg(self.accent_color).bold()
+            } else if !entry.is_current {
+                Style::default().dim()
+            } else {
+                Style::default()
+            };
+            let mut title_spans = vec![
                 Span::styled(marker.to_string(), marker_style),
                 Span::raw(" "),
-                Span::raw(entry.display_name.clone()),
-            ]);
-            if is_selected {
-                title = title.style(Style::default().fg(self.accent_color).bold());
-            } else if !entry.is_current {
-                title = title.dim();
+                Span::styled(entry.display_name.clone(), label_style),
+            ];
+            if let Some(right_hint) = entry
+                .right_hint
+                .as_deref()
+                .map(str::trim)
+                .filter(|right_hint| !right_hint.is_empty())
+            {
+                let title_width = Line::from(title_spans.clone()).width();
+                let right_hint_width = UnicodeWidthStr::width(right_hint);
+                let padding = usize::from(width)
+                    .saturating_sub(title_width + right_hint_width)
+                    .max(2);
+                title_spans.push(Span::raw(" ".repeat(padding)));
+                title_spans.push(Span::styled(right_hint.to_string(), Style::default().dim()));
             }
-            lines.push(title);
+            lines.push(Line::from(title_spans));
             if let Some(description) = entry.description.as_deref()
                 && !description.trim().is_empty()
             {
@@ -1106,10 +1124,10 @@ impl BottomPaneView for ModelPickerView {
 
 impl Renderable for ModelPickerView {
     fn render(&self, area: Rect, buf: &mut Buffer) {
-        Paragraph::new(self.render_lines()).render(area, buf);
+        Paragraph::new(self.render_lines(area.width)).render(area, buf);
     }
 
-    fn desired_height(&self, _width: u16) -> u16 {
-        u16::try_from(self.render_lines().len()).unwrap_or(u16::MAX)
+    fn desired_height(&self, width: u16) -> u16 {
+        u16::try_from(self.render_lines(width).len()).unwrap_or(u16::MAX)
     }
 }