fix: preserve provider model bindings

Author: wangtsiao

crates/core/src/conversation/records.rs

@@ -29,6 +29,9 @@ pub struct SessionRecord {
     pub model_provider: String,
     /// The latest resolved model slug for the session.
     pub model: Option<String>,
+    /// The latest selected provider model binding id for the session.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub model_binding_id: Option<String>,
     /// The logical thinking selection used as the default for the next turn.
     pub thinking: Option<String>,
     /// The working directory associated with the session.
@@ -87,6 +90,9 @@ pub struct TurnRecord {
     pub kind: TurnKind,
     /// The logical model selection used for the turn.
     pub model: String,
+    /// The selected provider model binding id used for the turn, when available.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub model_binding_id: Option<String>,
     /// The logical thinking selection used for the turn.
     pub thinking: Option<String>,
     /// The concrete request model used to execute the turn.
@@ -413,6 +419,7 @@ mod tests {
             agent_path: None,
             model_provider: "test".into(),
             model: None,
+            model_binding_id: None,
             thinking: None,
             cwd: ".".into(),
             cli_version: "0.1.0".into(),
@@ -868,6 +875,7 @@ mod tests {
             agent_path: None,
             model_provider: "test-provider".into(),
             model: Some("test-model".into()),
+            model_binding_id: Some("test-binding".into()),
             thinking: None,
             cwd: "/tmp/test".into(),
             cli_version: "0.1.0".into(),
@@ -898,6 +906,7 @@ mod tests {
             status,
             kind: crate::TurnKind::Regular,
             model: "test-model".into(),
+            model_binding_id: Some("test-binding".into()),
             thinking: None,
             request_model: "test-model".into(),
             request_thinking: None,

crates/core/src/session.rs

@@ -72,6 +72,9 @@ pub struct TurnConfig {
     /// Provider wire model name from the selected binding's `model_name`.
     /// This is the string sent as `ModelRequest.model` for the base model.
     pub request_model: String,
+    /// Provider model binding id selected for this turn, when the request was
+    /// resolved through configured provider bindings.
+    pub model_binding_id: Option<String>,
     /// Provider-scoped variant lookup used when thinking resolves to another
     /// catalog slug before the request is built.
     pub provider_request_models: ProviderRequestModelMap,
@@ -117,6 +120,7 @@ impl TurnConfig {
         Self {
             model,
             request_model,
+            model_binding_id: None,
             provider_request_models: ProviderRequestModelMap::default(),
             provider_route: ProviderRoute::Default,
             web_search: ResolvedWebSearchConfig::Disabled,
@@ -189,6 +193,7 @@ impl TurnConfig {
         Self {
             model,
             request_model,
+            model_binding_id: None,
             provider_request_models,
             provider_route,
             web_search,

crates/protocol/src/session.rs

@@ -43,6 +43,8 @@ pub struct SessionMetadata {
     pub agent_role: Option<String>,
     pub ephemeral: bool,
     pub model: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub model_binding_id: Option<String>,
     pub thinking: Option<String>,
     pub reasoning_effort: Option<ReasoningEffort>,
     pub total_input_tokens: usize,
@@ -67,6 +69,8 @@ pub struct SessionStartParams {
     pub ephemeral: bool,
     pub title: Option<String>,
     pub model: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub model_binding_id: Option<String>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
@@ -208,6 +212,8 @@ pub struct SessionTitleUpdateResult {
 pub struct SessionMetadataUpdateParams {
     pub session_id: SessionId,
     pub model: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub model_binding_id: Option<String>,
     pub thinking: Option<String>,
 }
 
@@ -366,6 +372,7 @@ mod tests {
             agent_role: None,
             ephemeral: false,
             model: Some("test-model".to_string()),
+            model_binding_id: Some("test-binding".to_string()),
             thinking: Some("medium".to_string()),
             reasoning_effort: Some(crate::ReasoningEffort::Medium),
             total_input_tokens: 12,

crates/protocol/src/turn.rs

@@ -13,6 +13,8 @@ pub struct TurnMetadata {
     pub status: TurnStatus,
     pub kind: TurnKind,
     pub model: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub model_binding_id: Option<String>,
     pub thinking: Option<String>,
     pub reasoning_effort: Option<ReasoningEffort>,
     pub request_model: String,
@@ -86,6 +88,8 @@ pub struct TurnStartParams {
     pub session_id: SessionId,
     pub input: Vec<InputItem>,
     pub model: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub model_binding_id: Option<String>,
     pub thinking: Option<String>,
     pub sandbox: Option<String>,
     pub approval_policy: Option<String>,
@@ -200,6 +204,7 @@ mod tests {
             status: TurnStatus::Completed,
             kind: TurnKind::Regular,
             model: "logical-model".to_string(),
+            model_binding_id: Some("provider-binding".to_string()),
             thinking: Some("high".to_string()),
             reasoning_effort: Some(ReasoningEffort::High),
             request_model: "provider-model".to_string(),

crates/server/src/db.rs

@@ -190,6 +190,7 @@ impl Database {
                 agent_role: None,
                 ephemeral: ephemeral != 0,
                 model,
+                model_binding_id: None,
                 thinking,
                 reasoning_effort: None,
                 total_input_tokens: 0,
@@ -257,6 +258,7 @@ impl Database {
                     agent_role: None,
                     ephemeral: ephemeral != 0,
                     model,
+                    model_binding_id: None,
                     thinking,
                     reasoning_effort: None,
                     total_input_tokens: 0,
@@ -547,6 +549,7 @@ mod tests {
             agent_role: None,
             ephemeral: false,
             model: Some("claude-sonnet-4-20250514".into()),
+            model_binding_id: None,
             thinking: None,
             reasoning_effort: None,
             total_input_tokens: 0,

crates/server/src/execution.rs

@@ -288,7 +288,8 @@ impl ServerRuntimeDependencies {
             let provider_request_models = ProviderRequestModelMap::new(
                 provider_request_model_map_for_binding(&provider_config, &binding),
             );
-            return TurnConfig::with_provider_route_and_web_tools(
+            let binding_id = binding.binding_id.clone();
+            let mut turn_config = TurnConfig::with_provider_route_and_web_tools(
                 self.catalog_model_or_fallback(&binding.model_slug),
                 binding.model_name,
                 provider_request_models,
@@ -297,6 +298,8 @@ impl ServerRuntimeDependencies {
                 web_fetch,
                 thinking_selection,
             );
+            turn_config.model_binding_id = Some(binding_id);
+            return turn_config;
         }
 
         let model = self.resolve_turn_model(requested_model);

crates/server/src/persistence.rs

@@ -92,6 +92,7 @@ impl RolloutStore {
         cwd: PathBuf,
         title: Option<String>,
         model: Option<String>,
+        model_binding_id: Option<String>,
         thinking: Option<String>,
         model_provider: String,
         parent_session_id: Option<SessionId>,
@@ -112,6 +113,7 @@ impl RolloutStore {
             agent_path: None,
             model_provider,
             model,
+            model_binding_id,
             thinking,
             cwd,
             cli_version: env!("CARGO_PKG_VERSION").into(),
@@ -391,6 +393,7 @@ impl ReplayState {
                     status: line.turn.status.clone(),
                     kind: line.turn.kind.clone(),
                     model: line.turn.model.clone(),
+                    model_binding_id: line.turn.model_binding_id.clone(),
                     thinking: line.turn.thinking.clone(),
                     reasoning_effort: line
                         .turn
@@ -527,13 +530,19 @@ impl ReplayState {
             .div_ceil(4);
         let pending_turn_queue = std::sync::Arc::clone(&core_session.pending_turn_queue);
         let btw_input_queue = std::sync::Arc::clone(&core_session.btw_input_queue);
-        let summary_model = self
+        let summary_model_selection = self
             .latest_turn_metadata
             .as_ref()
-            .map(|turn| turn.model.clone())
+            .and_then(|turn| turn.model_binding_id.clone())
+            .or_else(|| {
+                self.latest_turn_metadata
+                    .as_ref()
+                    .map(|turn| turn.model.clone())
+            })
+            .or_else(|| record.model_binding_id.clone())
             .or_else(|| record.model.clone())
             .unwrap_or_else(|| deps.default_model.clone());
-        let turn_config = deps.resolve_turn_config(Some(&summary_model), None);
+        let turn_config = deps.resolve_turn_config(Some(&summary_model_selection), None);
         let concrete_selection = |selection: Option<&str>| {
             selection
                 .map(str::trim)
@@ -565,6 +574,7 @@ impl ReplayState {
             .resolve_thinking_selection(summary_thinking.as_deref())
             .effective_reasoning_effort;
         record.model = Some(turn_config.model.slug.clone());
+        record.model_binding_id = turn_config.model_binding_id.clone();
         record.thinking = summary_thinking.clone();
 
         let summary = SessionMetadata {
@@ -580,6 +590,7 @@ impl ReplayState {
             agent_role: record.agent_role.clone(),
             ephemeral: false,
             model: Some(turn_config.model.slug),
+            model_binding_id: turn_config.model_binding_id.clone(),
             thinking: summary_thinking,
             reasoning_effort: summary_reasoning_effort,
             total_input_tokens: self.total_input_tokens,
@@ -1147,6 +1158,7 @@ pub(crate) fn build_turn_record(
         status: turn.status.clone(),
         kind: turn.kind.clone(),
         model: turn.model.clone(),
+        model_binding_id: turn.model_binding_id.clone(),
         thinking: turn.thinking.clone(),
         request_model: turn.request_model.clone(),
         request_thinking: turn.request_thinking.clone(),
@@ -1491,6 +1503,7 @@ mod tests {
                     agent_path: None,
                     model_provider: "test".into(),
                     model: Some("model-a".into()),
+                    model_binding_id: None,
                     thinking: None,
                     cwd: PathBuf::from("/tmp/root"),
                     cli_version: "0.1.0".into(),
@@ -1523,6 +1536,7 @@ mod tests {
                     status: TurnStatus::Completed,
                     kind: devo_core::TurnKind::Regular,
                     model: "model-b".into(),
+                    model_binding_id: None,
                     thinking: Some("enabled".into()),
                     request_model: "model-b".into(),
                     request_thinking: Some("enabled".into()),

crates/server/src/projection.rs

@@ -407,6 +407,7 @@ impl SessionProjector for DefaultProjection {
             agent_role: session.agent_role.clone(),
             ephemeral,
             model: session.model.clone(),
+            model_binding_id: session.model_binding_id.clone(),
             thinking: session.thinking.clone(),
             reasoning_effort: session
                 .latest_turn_context
@@ -438,6 +439,7 @@ impl TurnProjector for DefaultProjection {
             status: turn.status.clone(),
             kind: turn.kind.clone(),
             model: turn.model.clone(),
+            model_binding_id: turn.model_binding_id.clone(),
             thinking: turn.thinking.clone(),
             reasoning_effort: turn
                 .turn_context

crates/server/src/runtime.rs

@@ -211,6 +211,46 @@ impl TurnInputMode {
     }
 }
 
+fn session_model_selection(session: &SessionMetadata) -> Option<&str> {
+    session
+        .model_binding_id
+        .as_deref()
+        .or(session.model.as_deref())
+}
+
+fn requested_model_selection<'a>(
+    model_binding_id: Option<&'a str>,
+    model: Option<&'a str>,
+    session: &'a SessionMetadata,
+) -> Option<&'a str> {
+    model_binding_id
+        .or(model)
+        .or_else(|| session_model_selection(session))
+}
+
+fn apply_turn_config_to_session_summary(summary: &mut SessionMetadata, turn_config: &TurnConfig) {
+    summary.model = Some(turn_config.model.slug.clone());
+    summary.model_binding_id = turn_config.model_binding_id.clone();
+    summary.thinking = turn_config.thinking_selection.clone();
+}
+
+fn string_field_from_pending_metadata(
+    metadata: Option<&serde_json::Value>,
+    key: &str,
+) -> Option<String> {
+    metadata?
+        .get(key)?
+        .as_str()
+        .map(str::trim)
+        .filter(|value| !value.is_empty())
+        .map(str::to_string)
+}
+
+fn model_selection_from_pending_metadata(metadata: Option<&serde_json::Value>) -> Option<String> {
+    string_field_from_pending_metadata(metadata, "model_binding_id")
+        .or_else(|| string_field_from_pending_metadata(metadata, "model"))
+}
+
 impl ServerRuntime {
     pub fn new(server_home: PathBuf, deps: ServerRuntimeDependencies) -> Arc<Self> {
         let rollout_store = RolloutStore::new(server_home.clone());

crates/server/src/runtime/agents.rs

@@ -71,6 +71,7 @@ impl ServerRuntime {
             .unwrap_or_else(|| "root".to_string());
         let agent_path = AgentPath::new(parent_path).join(&nickname).0;
         let model = parent_summary.model.clone();
+        let model_binding_id = parent_summary.model_binding_id.clone();
         let thinking = parent_summary.thinking.clone();
 
         let mut record = self.rollout_store.create_session_record(
@@ -79,6 +80,7 @@ impl ServerRuntime {
             parent_summary.cwd.clone(),
             Some(nickname.clone()),
             model.clone(),
+            model_binding_id.clone(),
             thinking.clone(),
             self.deps.provider.name().to_string(),
             Some(parent_session_id),
@@ -139,6 +141,7 @@ impl ServerRuntime {
             agent_role: Some(role.clone()),
             ephemeral: params.ephemeral,
             model: model.clone(),
+            model_binding_id: model_binding_id.clone(),
             thinking,
             reasoning_effort: None,
             total_input_tokens: 0,
@@ -416,7 +419,7 @@ impl ServerRuntime {
         let (turn_config, resolved_request) = {
             let session = session_arc.lock().await;
             let turn_config = self.deps.resolve_turn_config(
-                session.summary.model.as_deref(),
+                session_model_selection(&session.summary),
                 session.summary.thinking.clone(),
             );
             let resolved_request = turn_config
@@ -438,6 +441,7 @@ impl ServerRuntime {
                 status: TurnStatus::Running,
                 kind: devo_core::TurnKind::Regular,
                 model: turn_config.model.slug.clone(),
+                model_binding_id: turn_config.model_binding_id.clone(),
                 thinking: turn_config.thinking_selection.clone(),
                 reasoning_effort: resolved_request.effective_reasoning_effort,
                 request_model,
@@ -448,8 +452,7 @@ impl ServerRuntime {
             };
             session.summary.status = SessionRuntimeStatus::ActiveTurn;
             session.summary.updated_at = now;
-            session.summary.model = Some(turn_config.model.slug.clone());
-            session.summary.thinking = turn_config.thinking_selection.clone();
+            apply_turn_config_to_session_summary(&mut session.summary, &turn_config);
             session.active_turn = Some(turn.clone());
             turn
         };