Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
agent: Preserve saved model selection until provider loads (#59417)
Neel080838387a76
diff --git a/crates/agent/src/agent.rs b/crates/agent/src/agent.rsindex eed1f118db3..2b0d852bc8e 100644--- a/crates/agent/src/agent.rs+++ b/crates/agent/src/agent.rs@@ -1369,12 +1369,8 @@ impl NativeAgent {for session in self.sessions.values_mut() {session.thread.update(cx, |thread, cx| {- if thread.model().is_none()- && let Some(model) = default_model.clone()- {- thread.set_model(model, cx);- cx.notify();- }+ thread.ensure_model(default_model.as_ref(), cx);+if let Some(model) = summarization_model.clone() {if thread.summarization_model().is_none()|| matches!(event, language_model::Event::ThreadSummaryModelChanged)@@ -6023,6 +6019,212 @@ mod internal_tests {drop(reloaded_acp_thread);}+ async fn persist_thread_with_fake_corp_model(+ cx: &mut TestAppContext,+ ) -> (+ Entity<NativeAgent>,+ Rc<NativeAgentConnection>,+ Entity<Project>,+ acp::SessionId,+ Arc<FakeLanguageModelProvider>,+ ) {+ let fs = FakeFs::new(cx.executor());+ fs.insert_tree("/", json!({ "a": {} })).await;+ let project = Project::test(fs.clone(), [path!("/a").as_ref()], cx).await;+ let thread_store = cx.new(|cx| ThreadStore::new(cx));+ let agent = cx+ .update(|cx| NativeAgent::new(thread_store.clone(), Templates::new(), fs.clone(), cx));+ let connection = Rc::new(NativeAgentConnection(agent.clone()));++ let model = Arc::new(FakeLanguageModel::with_id_and_thinking(+ "fake-corp",+ "custom-model-id",+ "Custom Model Display Name",+ false,+ ));+ let provider = Arc::new(+ FakeLanguageModelProvider::new(+ LanguageModelProviderId::from("fake-corp".to_string()),+ LanguageModelProviderName::from("Fake Corp".to_string()),+ )+ .with_models(vec![model.clone()]),+ );+ cx.update(|cx| {+ LanguageModelRegistry::global(cx).update(cx, |registry, cx| {+ registry.register_provider(provider.clone(), cx);+ });+ });+ agent.update(cx, |agent, cx| agent.models.refresh_list(cx));++ let acp_thread = cx+ .update(|cx| {+ connection.clone().new_session(+ project.clone(),+ PathList::new(&[Path::new("/a")]),+ cx,+ )+ })+ .await+ .unwrap();+ let session_id = acp_thread.read_with(cx, |thread, _| thread.session_id().clone());++ let selector = connection.model_selector(&session_id).unwrap();+ cx.update(|cx| selector.select_model(AgentModelId::new("fake-corp/custom-model-id"), cx))+ .await+ .unwrap();++ let send = acp_thread.update(cx, |thread, cx| thread.send(vec!["Hello".into()], cx));+ let send = cx.foreground_executor().spawn(send);+ cx.run_until_parked();+ model.send_last_completion_stream_text_chunk("Response.");+ model.end_last_completion_stream();+ send.await.unwrap();+ cx.run_until_parked();++ cx.update(|cx| connection.clone().close_session(&session_id, cx))+ .await+ .unwrap();+ drop(acp_thread);++ (agent, connection, project, session_id, provider)+ }++ fn unregister_fake_corp(cx: &mut TestAppContext) {+ cx.update(|cx| {+ LanguageModelRegistry::global(cx).update(cx, |registry, cx| {+ registry.unregister_provider(+ LanguageModelProviderId::from("fake-corp".to_string()),+ cx,+ );+ });+ });+ }++ #[gpui::test]+ async fn test_loaded_thread_resolves_model_when_provider_loads_late(cx: &mut TestAppContext) {+ init_test(cx);+ let (agent, _connection, project, session_id, provider) =+ persist_thread_with_fake_corp_model(cx).await;++ // Simulate a restart where the provider hasn't fetched its model list+ // yet, so the saved selection can't be resolved at load time.+ unregister_fake_corp(cx);++ let reloaded_acp_thread = agent+ .update(cx, |agent, cx| {+ agent.open_thread(session_id.clone(), project.clone(), cx)+ })+ .await+ .unwrap();+ let thread = agent.read_with(cx, |agent, _| {+ agent.sessions.get(&session_id).unwrap().thread.clone()+ });+ thread.read_with(cx, |thread, _| {+ assert!(+ thread.model().is_none(),+ "should not fall back to an unrelated model"+ );+ });++ // The original selection is persisted even while unresolved, so a save+ // during the window can't overwrite the user's choice with a fallback.+ let db_thread = thread.read_with(cx, |thread, cx| thread.to_db(cx)).await;+ let saved = db_thread.model.expect("selection should be persisted");+ assert_eq!(saved.provider, "fake-corp");+ assert_eq!(saved.model, "custom-model-id");++ cx.update(|cx| {+ LanguageModelRegistry::global(cx).update(cx, |registry, cx| {+ registry.register_provider(provider.clone(), cx);+ });+ });+ cx.run_until_parked();++ thread.read_with(cx, |thread, _| {+ assert_eq!(+ thread+ .model()+ .expect("model should resolve once provider loads")+ .id()+ .0+ .as_ref(),+ "custom-model-id"+ );+ });++ drop(reloaded_acp_thread);+ }++ #[gpui::test]+ async fn test_explicit_model_selection_cancels_pending(cx: &mut TestAppContext) {+ init_test(cx);+ let (agent, connection, project, session_id, provider) =+ persist_thread_with_fake_corp_model(cx).await;++ unregister_fake_corp(cx);++ let reloaded_acp_thread = agent+ .update(cx, |agent, cx| {+ agent.open_thread(session_id.clone(), project.clone(), cx)+ })+ .await+ .unwrap();+ let thread = agent.read_with(cx, |agent, _| {+ agent.sessions.get(&session_id).unwrap().thread.clone()+ });+ thread.read_with(cx, |thread, _| {+ assert!(thread.model().is_none());+ });++ // The user explicitly picks a different, available model.+ let other_model = Arc::new(FakeLanguageModel::with_id_and_thinking(+ "other-corp",+ "other-model-id",+ "Other Model",+ false,+ ));+ let other_provider = Arc::new(+ FakeLanguageModelProvider::new(+ LanguageModelProviderId::from("other-corp".to_string()),+ LanguageModelProviderName::from("Other Corp".to_string()),+ )+ .with_models(vec![other_model.clone()]),+ );+ cx.update(|cx| {+ LanguageModelRegistry::global(cx).update(cx, |registry, cx| {+ registry.register_provider(other_provider, cx);+ });+ });+ cx.run_until_parked();++ let selector = connection.model_selector(&session_id).unwrap();+ cx.update(|cx| selector.select_model(AgentModelId::new("other-corp/other-model-id"), cx))+ .await+ .unwrap();++ thread.read_with(cx, |thread, _| {+ assert_eq!(thread.model().unwrap().id().0.as_ref(), "other-model-id");+ });++ // The original provider returning must not clobber the explicit choice.+ cx.update(|cx| {+ LanguageModelRegistry::global(cx).update(cx, |registry, cx| {+ registry.register_provider(provider.clone(), cx);+ });+ });+ cx.run_until_parked();++ thread.read_with(cx, |thread, _| {+ assert_eq!(+ thread.model().unwrap().id().0.as_ref(),+ "other-model-id",+ "a late provider load must not override the explicit selection"+ );+ });++ drop(reloaded_acp_thread);+ }+#[gpui::test]async fn test_save_load_thread(cx: &mut TestAppContext) {init_test(cx);diff --git a/crates/agent/src/thread.rs b/crates/agent/src/thread.rsindex 0bae32da679..22326ee8d4b 100644--- a/crates/agent/src/thread.rs+++ b/crates/agent/src/thread.rs@@ -1136,6 +1136,37 @@ enum CompletionError {Other(#[from] anyhow::Error),}+pub(crate) enum ThreadModel {+ Ready(Arc<dyn LanguageModel>),+ Unresolved(SelectedModel),+ Unset,+}++impl ThreadModel {+ fn as_model(&self) -> Option<&Arc<dyn LanguageModel>> {+ match self {+ Self::Ready(model) => Some(model),+ Self::Unresolved(_) | Self::Unset => None,+ }+ }+}++impl From<&ThreadModel> for Option<DbLanguageModel> {+ fn from(model: &ThreadModel) -> Self {+ match model {+ ThreadModel::Ready(model) => Some(DbLanguageModel {+ provider: model.provider_id().to_string(),+ model: model.id().0.to_string(),+ }),+ ThreadModel::Unresolved(selection) => Some(DbLanguageModel {+ provider: selection.provider.0.to_string(),+ model: selection.model.0.to_string(),+ }),+ ThreadModel::Unset => None,+ }+ }+}+pub struct Thread {id: acp::SessionId,prompt_id: PromptId,@@ -1169,7 +1200,7 @@ pub struct Thread {profile_id: AgentProfileId,project_context: Entity<ProjectContext>,pub(crate) templates: Arc<Templates>,- model: Option<Arc<dyn LanguageModel>>,+ model: ThreadModel,summarization_model: Option<Arc<dyn LanguageModel>>,thinking_enabled: bool,thinking_effort: Option<String>,@@ -1278,6 +1309,7 @@ impl Thread {.and_then(|model| model.speed);let (prompt_capabilities_tx, prompt_capabilities_rx) =watch::channel(Self::prompt_capabilities(model.as_deref()));+ let model = model.map_or(ThreadModel::Unset, ThreadModel::Ready);Self {id: acp::SessionId::new(uuid::Uuid::new_v4().to_string()),prompt_id: PromptId::new(),@@ -1354,13 +1386,13 @@ impl Thread {return;};- self.model = Some(model.clone());self.thinking_enabled = selection.enable_thinking && model.supports_thinking();self.thinking_effort = selection.effort.clone();self.speed = selection.speed.filter(|_| model.supports_fast_mode());self.prompt_capabilities_tx- .send(Self::prompt_capabilities(self.model.as_deref()))+ .send(Self::prompt_capabilities(Some(model.as_ref()))).log_err();+ self.model = ThreadModel::Ready(model);}pub fn id(&self) -> &acp::SessionId {@@ -1630,31 +1662,33 @@ impl Thread {.profile.unwrap_or_else(|| settings.default_profile.clone());- let mut model = LanguageModelRegistry::global(cx).update(cx, |registry, cx| {- db_thread- .model- .and_then(|model| {- let model = SelectedModel {- provider: model.provider.clone().into(),- model: model.model.into(),- };- registry.select_model(&model, cx)- })- .or_else(|| registry.default_model())- .map(|model| model.model)+ let saved_selection = db_thread.model.map(|model| SelectedModel {+ provider: model.provider.into(),+ model: model.model.into(),});- if model.is_none() {- model = Self::resolve_profile_model(&profile_id, cx);- }- if model.is_none() {- model = LanguageModelRegistry::global(cx).update(cx, |registry, _cx| {- registry.default_model().map(|model| model.model)- });- }+ let resolved_saved_model = LanguageModelRegistry::global(cx).update(cx, |registry, cx| {+ saved_selection+ .as_ref()+ .and_then(|selection| registry.select_model(selection, cx))+ .map(|configured| configured.model)+ });- let (prompt_capabilities_tx, prompt_capabilities_rx) =- watch::channel(Self::prompt_capabilities(model.as_deref()));+ let model = match (resolved_saved_model, saved_selection) {+ (Some(model), _) => ThreadModel::Ready(model),+ (None, Some(selection)) => ThreadModel::Unresolved(selection),+ (None, None) => Self::resolve_profile_model(&profile_id, cx)+ .or_else(|| {+ LanguageModelRegistry::global(cx).update(cx, |registry, _cx| {+ registry.default_model().map(|model| model.model)+ })+ })+ .map_or(ThreadModel::Unset, ThreadModel::Ready),+ };++ let (prompt_capabilities_tx, prompt_capabilities_rx) = watch::channel(+ Self::prompt_capabilities(model.as_model().map(|model| model.as_ref())),+ );let action_log = cx.new(|_| ActionLog::new(project.clone()));@@ -1719,10 +1753,7 @@ impl Thread {initial_project_snapshot: None,cumulative_token_usage: self.cumulative_token_usage,request_token_usage: self.request_token_usage.clone(),- model: self.model.as_ref().map(|model| DbLanguageModel {- provider: model.provider_id().to_string(),- model: model.id().0.to_string(),- }),+ model: (&self.model).into(),profile: Some(self.profile_id.clone()),imported: self.imported,subagent_context: self.subagent_context.clone(),@@ -1795,13 +1826,35 @@ impl Thread {}pub fn model(&self) -> Option<&Arc<dyn LanguageModel>> {- self.model.as_ref()+ self.model.as_model()+ }++ pub(crate) fn ensure_model(+ &mut self,+ default_model: Option<&Arc<dyn LanguageModel>>,+ cx: &mut Context<Self>,+ ) {+ let resolved = match &self.model {+ ThreadModel::Ready(_) => return,+ ThreadModel::Unresolved(selection) => {+ LanguageModelRegistry::global(cx).update(cx, |registry, cx| {+ registry+ .select_model(selection, cx)+ .map(|configured| configured.model)+ })+ }+ ThreadModel::Unset => default_model.cloned(),+ };++ if let Some(model) = resolved {+ self.set_model(model, cx);+ }}pub fn set_model(&mut self, model: Arc<dyn LanguageModel>, cx: &mut Context<Self>) {let old_usage = self.latest_token_usage();- self.model = Some(model.clone());- let new_caps = Self::prompt_capabilities(self.model.as_deref());+ self.model = ThreadModel::Ready(model.clone());+ let new_caps = Self::prompt_capabilities(self.model.as_model().map(|model| model.as_ref()));let new_usage = self.latest_token_usage();if old_usage != new_usage {cx.emit(TokenUsageUpdated(new_usage));@@ -2137,7 +2190,7 @@ impl Thread {pub fn latest_token_usage(&self) -> Option<acp_thread::TokenUsage> {let usage = self.latest_request_token_usage()?;- let model = self.model.clone()?;+ let model = self.model()?;let input_tokens = total_input_tokens(usage);Some(acp_thread::TokenUsage {@@ -2256,8 +2309,8 @@ impl Thread {cx: &mut Context<Self>,) -> Result<mpsc::UnboundedReceiver<Result<ThreadEvent>>> {let model = self- .model- .clone()+ .model()+ .cloned().ok_or_else(|| anyhow!(NoModelConfiguredError))?;// Flush any pending message and cancel an in-flight turn before we@@ -2536,7 +2589,7 @@ impl Thread {let (model, request) = this.update(cx, |this, cx| {let model = refusal_fallback_model.clone()- .or_else(|| this.model.clone())+ .or_else(|| this.model().cloned()).ok_or_else(|| anyhow!(NoModelConfiguredError))?;this.refresh_turn_tools(cx);let request = this.build_completion_request(intent, cx)?;@@ -2683,7 +2736,7 @@ impl Thread {if had_refusal {let maybe_fallback = this.update(cx, |this, cx| -> Option<Arc<dyn LanguageModel>> {- let current_model = refusal_fallback_model.as_ref().or(this.model.as_ref())?;+ let current_model = refusal_fallback_model.as_ref().or(this.model())?;let fallback_id = match current_model.refusal_fallback_model_id() {Some(id) => id,None => {@@ -2830,7 +2883,7 @@ impl Thread {) -> Result<ControlFlow<()>> {let Some((model, request, insertion_ix)) = this.update(cx, |this, cx| {let insertion_ix = this.compaction_message_target_ix(cx)?;- let model = this.model.clone()?;+ let model = this.model().cloned()?;let request = this.build_compaction_request(insertion_ix, &model, cx);this.current_request_token_usage = TokenUsage::default();// Preserve telemetry across retries so the retry count keeps@@ -2997,7 +3050,7 @@ impl Thread {attempt: u8,plan: Option<Plan>,) -> Result<acp_thread::RetryStatus> {- let Some(model) = self.model.as_ref() else {+ let Some(model) = self.model() else {return Err(anyhow!(error));};@@ -3103,8 +3156,8 @@ impl Thread {thread_id = self.id.to_string(),parent_thread_id = self.parent_thread_id().map(|id| id.to_string()),prompt_id = self.prompt_id.to_string(),- model = self.model.as_ref().map(|m| m.telemetry_id()),- model_provider = self.model.as_ref().map(|m| m.provider_id().to_string()),+ model = self.model().map(|m| m.telemetry_id()),+ model_provider = self.model().map(|m| m.provider_id().to_string()),input_tokens = usage.input_tokens,output_tokens = usage.output_tokens,cache_creation_input_tokens = usage.cache_creation_input_tokens,@@ -3720,7 +3773,7 @@ impl Thread {}fn enabled_tools(&self, cx: &App) -> BTreeMap<SharedString, Arc<dyn AnyAgentTool>> {- let Some(model) = self.model.as_ref() else {+ let Some(model) = self.model() else {return BTreeMap::new();};let Some(profile) = AgentSettings::get_global(cx).profiles.get(&self.profile_id) else {@@ -3907,7 +3960,7 @@ impl Thread {let system_prompt = SystemPromptTemplate {project: self.project_context.read(cx),available_tools,- model_name: self.model.as_ref().map(|m| m.name().0.to_string()),+ model_name: self.model().map(|m| m.name().0.to_string()),date: Local::now().format("%Y-%m-%d").to_string(),user_agents_md,sandboxing: crate::sandboxing::sandboxing_enabled_for_project(@@ -3972,7 +4025,7 @@ impl Thread {trigger: &'static str,cx: &App,) -> Option<CompactionTelemetry> {- let model = self.model.as_ref()?;+ let model = self.model()?;let auto_compact = AgentSettings::get_global(cx).auto_compact;let max_tokens = model.max_token_count();let max_input_tokens = max_tokens.saturating_sub(model.max_output_tokens().unwrap_or(0));@@ -4014,7 +4067,7 @@ impl Thread {return None;}- let model = self.model.as_ref()?;+ let model = self.model()?;let max_token_count = model.max_token_count();let max_input_tokens =max_token_count.saturating_sub(model.max_output_tokens().unwrap_or(0));