diff --git a/codex-rs/app-server-client/src/cloud.rs b/codex-rs/app-server-client/src/cloud.rs index e412c9c991..d575c13170 100644 --- a/codex-rs/app-server-client/src/cloud.rs +++ b/codex-rs/app-server-client/src/cloud.rs @@ -35,11 +35,11 @@ pub enum CloudOperation { }, /// Sent on the scoped channel after the caller has prepared the replacement view. CommitPreparedResume, - /// Host project metadata stays on the private transport, outside the app-server wire. - StartProjectThread { + /// Environment selection stays on the private transport, outside the app-server wire. + StartThreadWithEnvironment { request_id: RequestId, params: Box, - project: codex_cloud_client::ProjectEnvironment, + environment: codex_cloud_client::EnvironmentSelection, }, SubmitUserMessage(Box), /// Apply the result of a name write that already succeeded outside the command queue. @@ -339,16 +339,31 @@ impl CloudRequestHandle { }) } - pub(crate) async fn start_project_thread( + /// Discover saved environments using this Cloud connection's authenticated account. + pub async fn list_saved_environments( + &self, + ) -> Result, codex_cloud_client::Error> { + let catalog = self + .native + .as_ref() + .ok_or(codex_cloud_client::Error::InvalidCredentials)?; + let environments = catalog.list_saved_environments().await?; + if !catalog.model_catalog_is_current() { + return Err(codex_cloud_client::Error::InvalidCredentials); + } + Ok(environments) + } + + pub(crate) async fn start_thread_with_environment( &self, request_id: RequestId, params: codex_app_server_protocol::ThreadStartParams, - project: codex_cloud_client::ProjectEnvironment, + environment: codex_cloud_client::EnvironmentSelection, ) -> io::Result { - self.send(CloudOperation::StartProjectThread { + self.send(CloudOperation::StartThreadWithEnvironment { request_id, params: Box::new(params), - project, + environment, }) .await } diff --git a/codex-rs/app-server-client/src/cloud_backend/connection_tests.rs b/codex-rs/app-server-client/src/cloud_backend/connection_tests.rs index e3d45ab24a..8f72bc5b48 100644 --- a/codex-rs/app-server-client/src/cloud_backend/connection_tests.rs +++ b/codex-rs/app-server-client/src/cloud_backend/connection_tests.rs @@ -74,7 +74,7 @@ async fn rejected_rename_preserves_loaded_cloud_thread_name() -> Result<()> { }, }, cloud::SubmissionMode::StartIfIdle, - /*project*/ None, + /*environment*/ None, &mut requests, &mut replies, &output, @@ -154,7 +154,7 @@ async fn failed_archive_loaded_list_tracks_attachment_not_cached_metadata() -> R }, }, cloud::SubmissionMode::StartIfIdle, - /*project*/ None, + /*environment*/ None, &mut requests, &mut replies, &output, @@ -168,7 +168,7 @@ async fn failed_archive_loaded_list_tracks_attachment_not_cached_metadata() -> R params: Default::default(), }, cloud::SubmissionMode::StartIfIdle, - /*project*/ None, + /*environment*/ None, &mut requests, &mut replies, &output, @@ -202,7 +202,7 @@ async fn failed_archive_loaded_list_tracks_attachment_not_cached_metadata() -> R params: Default::default(), }, cloud::SubmissionMode::StartIfIdle, - /*project*/ None, + /*environment*/ None, &mut requests, &mut replies, &output, @@ -266,14 +266,14 @@ async fn dropping_an_in_flight_start_unblocks_the_native_worker() -> Result<()> request_id: protocol::RequestId::Integer(1), params: Default::default(), })), - CloudOperation::StartProjectThread { + CloudOperation::StartThreadWithEnvironment { request_id: protocol::RequestId::Integer(1), params: Box::default(), - project: cloud::ProjectEnvironment { + environment: cloud::EnvironmentSelection::Project(cloud::ProjectEnvironment { name: "project".into(), origin_urls: vec!["https://github.com/example/project.git".into()], cwd: None, - }, + }), }, ] { assert_abandoned_request_unblocks_worker("Prewarm", operation).await?; @@ -337,13 +337,13 @@ async fn assert_abandoned_request_unblocks_worker( let mut pending = Box::pin(async { match operation { CloudOperation::Request(request) => client.request(*request).await, - CloudOperation::StartProjectThread { + CloudOperation::StartThreadWithEnvironment { request_id, params, - project, + environment, } => { handle - .start_project_thread(request_id, *params, project) + .start_thread_with_environment(request_id, *params, environment) .await } _ => unreachable!("fixture supports Cloud lists and starts"), diff --git a/codex-rs/app-server-client/src/cloud_backend/mod.rs b/codex-rs/app-server-client/src/cloud_backend/mod.rs index 5b2410073d..355a77ba59 100644 --- a/codex-rs/app-server-client/src/cloud_backend/mod.rs +++ b/codex-rs/app-server-client/src/cloud_backend/mod.rs @@ -362,7 +362,7 @@ async fn run_worker_with_prepared( protocol::ClientRequest::ThreadResume { .. } => (false, true), _ => (false, false), }, - CloudOperation::StartProjectThread { .. } => (true, true), + CloudOperation::StartThreadWithEnvironment { .. } => (true, true), CloudOperation::PrepareThreadResume { .. } if command.response.is_closed() => continue, CloudOperation::PrepareThreadResume { .. } => (false, true), _ => (false, false), @@ -419,17 +419,17 @@ async fn run_worker_with_prepared( CloudOperation::CommitPreparedResume => Err(eyre!( "Cloud resume commit requires its scoped history handle." )), - CloudOperation::StartProjectThread { + CloudOperation::StartThreadWithEnvironment { request_id, params, - project, + environment, } => Ok(( protocol::ClientRequest::ThreadStart { request_id, params: *params, }, cloud::SubmissionMode::StartIfIdle, - Some(project), + Some(environment), )), CloudOperation::SubmitUserMessage(params) => Ok(( protocol::ClientRequest::TurnStart { @@ -448,7 +448,7 @@ async fn run_worker_with_prepared( )), }; let result = match request { - Ok((request, mode, project)) => { + Ok((request, mode, environment)) => { let unloads = prepared.as_ref().is_some_and(|candidate| { let id = match &request { protocol::ClientRequest::ThreadArchive { params, .. } => ¶ms.thread_id, @@ -479,7 +479,7 @@ async fn run_worker_with_prepared( } continue; } - result = handle_request(request, mode, project, requests, replies, output) => result, + result = handle_request(request, mode, environment, requests, replies, output) => result, }; if unloads && result.is_ok() @@ -556,7 +556,7 @@ async fn prepare_thread_resume( _ = ready.closed() => return None, prepared = async { let response = replies.while_listening( - requests.handle(request, cloud::SubmissionMode::StartIfIdle, /*project*/ None, output), + requests.handle(request, cloud::SubmissionMode::StartIfIdle, /*environment*/ None, output), output, ).await?; let requests::Response::Attach(settings) = response else { @@ -655,7 +655,7 @@ async fn advance_prepared_resume( _ = response.closed() => None, _ = output.closed() => None, page = replies.while_listening( - requests.handle(*request, cloud::SubmissionMode::StartIfIdle, /*project*/ None, &warning_output), + requests.handle(*request, cloud::SubmissionMode::StartIfIdle, /*environment*/ None, &warning_output), output, ) => Some(page), }; @@ -688,7 +688,7 @@ async fn advance_prepared_resume( async fn handle_request( request: protocol::ClientRequest, mode: cloud::SubmissionMode, - project: Option, + environment: Option, requests: &mut requests::Requests, replies: &mut Replies, output: &mpsc::UnboundedSender, @@ -731,7 +731,7 @@ async fn handle_request( _ => false, }; let response = { - let handling = requests.handle(request, mode, project, output); + let handling = requests.handle(request, mode, environment, output); tokio::pin!(handling); let immediate = if selected_mutation && let Some(recovery) = &mut replies.idle { // Local admission validation finishes before the RPC yields. Poll without diff --git a/codex-rs/app-server-client/src/cloud_backend/requests.rs b/codex-rs/app-server-client/src/cloud_backend/requests.rs index 1167a6e479..30a97c5304 100644 --- a/codex-rs/app-server-client/src/cloud_backend/requests.rs +++ b/codex-rs/app-server-client/src/cloud_backend/requests.rs @@ -78,7 +78,7 @@ impl Requests { &mut self, request: protocol::ClientRequest, mode: cloud::SubmissionMode, - project: Option, + environment: Option, output: &mpsc::UnboundedSender, ) -> Result { use protocol::ClientRequest as Request; @@ -130,7 +130,10 @@ impl Requests { "Cloud conversations start with server defaults. Custom settings are not supported yet." ); } - let settings = self.client.prewarm_thread(model, provider, project).await?; + let settings = self + .client + .prewarm_thread(model, provider, environment) + .await?; return attach_response(settings); } Request::ThreadResume { params, .. } => { diff --git a/codex-rs/app-server-client/src/lib.rs b/codex-rs/app-server-client/src/lib.rs index 5bc23c8638..388bbaa7a7 100644 --- a/codex-rs/app-server-client/src/lib.rs +++ b/codex-rs/app-server-client/src/lib.rs @@ -22,7 +22,9 @@ mod cloud; pub mod cloud_backend; +pub use codex_cloud_client::EnvironmentSelection; pub use codex_cloud_client::ProjectEnvironment; +pub use codex_cloud_client::SavedEnvironment; mod path; mod remote; mod remote_addr; @@ -725,22 +727,22 @@ impl InProcessAppServerRequestHandle { } impl AppServerRequestHandle { - /// Starts a native cloud thread with host project metadata without adding wire fields. - pub async fn start_cloud_project_thread( + /// Starts a native Cloud thread with a saved config or a default project checkout. + pub async fn start_cloud_thread_with_environment( &self, request_id: RequestId, params: codex_app_server_protocol::ThreadStartParams, - project: codex_cloud_client::ProjectEnvironment, + environment: codex_cloud_client::EnvironmentSelection, ) -> Result { let response = match self { Self::Cloud(handle) => { handle - .start_project_thread(request_id, params, project) + .start_thread_with_environment(request_id, params, environment) .await } Self::InProcess(_) | Self::Remote(_) => Err(IoError::new( std::io::ErrorKind::Unsupported, - "Project checkout requires the native cloud transport.", + "Selecting an environment requires the native Cloud transport.", )), }; decode_typed_response("thread/start", response) diff --git a/codex-rs/cloud-client/src/client_tests.rs b/codex-rs/cloud-client/src/client_tests.rs index 7fdd6c2449..76ec8bc824 100644 --- a/codex-rs/cloud-client/src/client_tests.rs +++ b/codex-rs/cloud-client/src/client_tests.rs @@ -312,10 +312,11 @@ async fn activation_preserves_native_settings_and_thread_metadata() { const PREWARM_CODEX_PLUGINS: &[u8] = b"\xe2\x01\x07\x0a\x05codex"; #[tokio::test] -async fn prewarm_defers_readiness_only_for_selected_projects() { +async fn prewarm_defers_readiness_for_explicit_environments() { let mut fixture = fixture_responses(vec![ response(vec![frame(&[])], tonic::Status::ok("")), response(vec![frame(&[])], tonic::Status::ok("")), + response(vec![frame(&[])], tonic::Status::ok("")), ]) .await; @@ -339,14 +340,14 @@ async fn prewarm_defers_readiness_only_for_selected_projects() { .prewarm_thread( /*model*/ None, /*model_provider*/ None, - Some(ProjectEnvironment { + Some(EnvironmentSelection::Project(ProjectEnvironment { name: "App".to_owned(), cwd: Some("/workspace/acme/app".to_owned()), origin_urls: vec![ "git@github.com:acme/app.git".to_owned(), "https://github.com/acme/lib.git".to_owned(), ], - }), + })), ) .await, Err(Error::InvalidResponse) @@ -365,6 +366,25 @@ async fn prewarm_defers_readiness_only_for_selected_projects() { ] .concat(); assert_request(&mut fixture, "Prewarm", &expected).await; + + assert!(matches!( + fixture + .client + .prewarm_thread( + /*model*/ None, + /*model_provider*/ None, + Some(EnvironmentSelection::Saved("ws~asenvcfg_saved".to_owned())), + ) + .await, + Err(Error::InvalidResponse) + )); + let expected = [ + b"\x52\x17\x0a\x15\x0a\x13\x0a\x11ws~asenvcfg_saved".as_slice(), + PREWARM_CODEX_PLUGINS, + b"\xe8\x01\x01", + ] + .concat(); + assert_request(&mut fixture, "Prewarm", &expected).await; } #[tokio::test] diff --git a/codex-rs/cloud-client/src/lib.rs b/codex-rs/cloud-client/src/lib.rs index 6d16142d0b..535d9a5d10 100644 --- a/codex-rs/cloud-client/src/lib.rs +++ b/codex-rs/cloud-client/src/lib.rs @@ -59,6 +59,7 @@ pub use items::CommandSummary; pub use items::ItemLifecycle; pub use items::ItemStatus; pub use items::ItemSummary; +pub use prewarm::EnvironmentSelection; pub use prewarm::ProjectEnvironment; pub use transcript::FileUpdate; pub use transcript::ItemDelta; diff --git a/codex-rs/cloud-client/src/prewarm.rs b/codex-rs/cloud-client/src/prewarm.rs index 627864a8d9..f46c5eb10d 100644 --- a/codex-rs/cloud-client/src/prewarm.rs +++ b/codex-rs/cloud-client/src/prewarm.rs @@ -16,6 +16,13 @@ pub struct ProjectEnvironment { pub cwd: Option, } +/// An explicit saved environment or the default environment with a project checkout. +#[derive(Clone, Debug)] +pub enum EnvironmentSelection { + Saved(String), + Project(ProjectEnvironment), +} + pub(super) const DEFAULT_ENVIRONMENT_CONFIG_ID: &str = "asenvcfg_base"; impl std::fmt::Debug for ProjectEnvironment { @@ -35,24 +42,28 @@ impl Client { model: Option, model_provider: Option, ) -> Result { - self.prewarm_thread(model, model_provider, /*project*/ None) + self.prewarm_thread(model, model_provider, /*environment*/ None) .await } - /// Prewarm a coding thread, deferring executor readiness for a selected project checkout. + /// Prewarm a coding thread, deferring executor readiness for an explicit environment. pub async fn prewarm_thread( &self, model: Option, model_provider: Option, - project: Option, + environment: Option, ) -> Result { - let deferred_environment = project.is_some().then_some(true); - let managed = match project { - Some(ProjectEnvironment { + let deferred_environment = environment.is_some().then_some(true); + let managed = match environment { + Some(EnvironmentSelection::Saved(id)) => wire::ManagedEnvironment { + environment_config_id: Some(id), + ..Default::default() + }, + Some(EnvironmentSelection::Project(ProjectEnvironment { name, origin_urls, cwd, - }) => wire::ManagedEnvironment { + })) => wire::ManagedEnvironment { environment_config_id: Some(DEFAULT_ENVIRONMENT_CONFIG_ID.to_owned()), cwd, overrides: Some(wire::EnvironmentOverrides { diff --git a/codex-rs/tui/src/app/backend_selection.rs b/codex-rs/tui/src/app/backend_selection.rs index e2dae94478..bacaec27bf 100644 --- a/codex-rs/tui/src/app/backend_selection.rs +++ b/codex-rs/tui/src/app/backend_selection.rs @@ -110,14 +110,18 @@ impl App { .filter(|owner| *owner != backends.displayed_owner()) } - pub(super) fn can_cycle_conversation_backend(&self) -> bool { - self.voice_owner_thread_id().is_none() - && self.chat_widget.can_choose_new_backend() - && self - .current_displayed_thread_id() - .and_then(|id| self.thread_event_channels.get(&id)) - .and_then(|channel| channel.store.try_lock().ok()) - .is_some_and(|store| store.session.is_some() && store.latest_turn_id.is_none()) + pub(super) fn backend_draft(&self) -> Option { + if self.voice_owner_thread_id().is_some() || !self.chat_widget.can_choose_new_backend() { + return None; + } + let thread_id = self.current_displayed_thread_id()?; + let store = self + .thread_event_channels + .get(&thread_id)? + .store + .try_lock() + .ok()?; + (store.session.is_some() && store.latest_turn_id.is_none()).then_some(thread_id) } pub(super) async fn start_new_session_on_other_backend( diff --git a/codex-rs/tui/src/app/startup.rs b/codex-rs/tui/src/app/startup.rs index cb364f2d1f..8a9ac4e784 100644 --- a/codex-rs/tui/src/app/startup.rs +++ b/codex-rs/tui/src/app/startup.rs @@ -1361,11 +1361,11 @@ See the Codex keymap documentation for supported actions and examples." } backends.replay_ready_side_startup(&app); let multi_backend = app.config.features.enabled(Feature::TuiMultiBackend); - let next_backend = if multi_backend && app.can_cycle_conversation_backend() { - backends.next_listening_backend(displayed_owner) - } else { - None - }; + let draft = multi_backend.then(|| app.backend_draft()).flatten(); + let next_backend = draft + .is_some() + .then(|| backends.next_listening_backend(displayed_owner)) + .flatten(); let current_label = next_backend.and_then(|_| backends.displayed_name(&app.app_server_target)); app.chat_widget.set_new_backend_control(current_label); diff --git a/codex-rs/tui/src/app/tests/new_session_tests.rs b/codex-rs/tui/src/app/tests/new_session_tests.rs index 05da1107b4..516143f258 100644 --- a/codex-rs/tui/src/app/tests/new_session_tests.rs +++ b/codex-rs/tui/src/app/tests/new_session_tests.rs @@ -1596,7 +1596,7 @@ async fn backend_cycling_waits_for_foreground_and_parked_voice_calls() -> Result Vec::new(), ) .await?; - assert!(app.can_cycle_conversation_backend()); + assert!(app.backend_draft().is_some()); crate::chatwidget::activate_voice_for_thread(&mut app.chat_widget, thread_id); if parked { let (visible, _, _, _) = @@ -1605,7 +1605,7 @@ async fn backend_cycling_waits_for_foreground_and_parked_voice_calls() -> Result } app.chat_widget .restore_user_message_to_composer("keep draft".into()); - assert!(!app.can_cycle_conversation_backend()); + assert!(app.backend_draft().is_none()); let mut backends = BackendSessions::from_initial(source, vec![destination]); let mut tui = crate::tui::test_support::make_test_tui()?; let error = app diff --git a/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs b/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs index 135bdcf885..3cf30b0530 100644 --- a/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs +++ b/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs @@ -6152,7 +6152,7 @@ fn fresh_session_keeps_its_name_and_draft_when_cycling_backends() -> Result<()> toml::from_str(&std::fs::read_to_string(&preference_path)?)?; Ok(saved["tui"]["default_hosts"].clone().try_into()?) }; - assert!(app.can_cycle_conversation_backend()); + assert!(app.backend_draft().is_some()); app.start_new_session_on_other_backend( &mut tui, &mut backends, diff --git a/codex-rs/tui/src/app_server_session.rs b/codex-rs/tui/src/app_server_session.rs index f1fc5364cc..52d8f172d7 100644 --- a/codex-rs/tui/src/app_server_session.rs +++ b/codex-rs/tui/src/app_server_session.rs @@ -611,6 +611,16 @@ pub(crate) enum TurnPermissionsOverride { )] pub(crate) struct UnsupportedLegacyPermissionProfile; +/// The environment choice for a new Cloud thread. +pub(crate) enum CloudThreadStart<'a> { + Project(Option<&'a std::path::Path>), + #[cfg_attr( + not(test), + expect(dead_code, reason = "saved starts are wired by the Cloud picker") + )] + Saved(String), +} + impl AppServerSession { /// Platform of the app-server process, not necessarily its executor. pub(crate) fn app_server_platform_family(&self) -> Option<&str> { @@ -1145,6 +1155,26 @@ impl AppServerSession { remote_cwd_override: Option<&std::path::Path>, selected_profile: Option<&PermissionProfileSelection>, host_project_cwd: Option<&std::path::Path>, + ) -> Result { + self.start_thread_with_environment( + local_settings, + config, + session_start_source, + remote_cwd_override, + selected_profile, + CloudThreadStart::Project(host_project_cwd), + ) + .await + } + + pub(crate) async fn start_thread_with_environment( + &mut self, + local_settings: &LocalSettings, + config: &Config, + session_start_source: Option, + remote_cwd_override: Option<&std::path::Path>, + selected_profile: Option<&PermissionProfileSelection>, + cloud_start: CloudThreadStart<'_>, ) -> Result { if self.thread_params_mode.settings_owner() == ThreadSettingsOwner::Server && selected_profile.is_some() @@ -1187,17 +1217,21 @@ impl AppServerSession { self.thread_tool_transport().configure(&mut params); } let request_handle = self.request_handle(); - let project = if self.thread_params_mode == ThreadParamsMode::Cloud { - match host_project_cwd { - Some(cwd) => cloud_project::from_local_cwd(cwd).await, - None => None, + use codex_app_server_client::EnvironmentSelection; + let environment = if self.thread_params_mode == ThreadParamsMode::Cloud { + match cloud_start { + CloudThreadStart::Saved(id) => Some(EnvironmentSelection::Saved(id)), + CloudThreadStart::Project(Some(cwd)) => cloud_project::from_local_cwd(cwd) + .await + .map(EnvironmentSelection::Project), + CloudThreadStart::Project(None) => None, } } else { None }; - let started = match project { - Some(project) => request_handle - .start_cloud_project_thread(request_id, params, project) + let started = match environment { + Some(environment) => request_handle + .start_cloud_thread_with_environment(request_id, params, environment) .await .map(|response| (response, ThreadHistorySupport::Paginated, false)), None => { diff --git a/codex-rs/tui/src/app_server_session/cloud_project_tests.rs b/codex-rs/tui/src/app_server_session/cloud_project_tests.rs index 317a122b5b..ba6fb2fe7f 100644 --- a/codex-rs/tui/src/app_server_session/cloud_project_tests.rs +++ b/codex-rs/tui/src/app_server_session/cloud_project_tests.rs @@ -30,6 +30,7 @@ async fn cloud_starts_use_each_requests_host_project_without_caching() { use codex_app_server_client::AppServerClient; use codex_app_server_client::CloudClient; use codex_app_server_client::CloudOperation; + use codex_app_server_client::EnvironmentSelection; use codex_app_server_protocol::ClientRequest; use codex_app_server_protocol::JSONRPCErrorError; @@ -76,13 +77,23 @@ async fn cloud_starts_use_each_requests_host_project_without_caching() { ThreadParamsMode::Cloud, ); let worker = tokio::spawn(async move { - for expected in [Some("first"), Some("second"), None, None, None, None] { + for expected in [ + Some("first"), + Some("second"), + Some("saved"), + None, + None, + None, + None, + ] { let command = commands.recv().await.unwrap(); match (expected, command.operation) { ( Some(expected), - CloudOperation::StartProjectThread { - params, project, .. + CloudOperation::StartThreadWithEnvironment { + params, + environment: EnvironmentSelection::Project(project), + .. }, ) => { assert_eq!(project.name, expected); @@ -94,6 +105,18 @@ async fn cloud_starts_use_each_requests_host_project_without_caching() { vec![format!("https://github.com/org/{expected}")] ); } + ( + Some("saved"), + CloudOperation::StartThreadWithEnvironment { + params, + environment: EnvironmentSelection::Saved(id), + .. + }, + ) => { + assert_eq!(id, "ws~asenvcfg_saved"); + assert_eq!(params.cwd, None); + assert_eq!(params.runtime_workspace_roots, None); + } (None, CloudOperation::Request(request)) => { assert!(matches!(*request, ClientRequest::ThreadStart { .. })) } @@ -109,23 +132,26 @@ async fn cloud_starts_use_each_requests_host_project_without_caching() { .unwrap(); } }); - for (mode, host) in [ - (ThreadParamsMode::Cloud, Some(nested.as_path())), - (ThreadParamsMode::Cloud, Some(second.path())), - (ThreadParamsMode::Cloud, Some(misleading.path())), - (ThreadParamsMode::Cloud, Some(projectless.path())), - (ThreadParamsMode::Cloud, None), - (ThreadParamsMode::Remote, Some(first.path())), + use super::super::CloudThreadStart::Project; + use super::super::CloudThreadStart::Saved; + for (mode, environment) in [ + (ThreadParamsMode::Cloud, Project(Some(nested.as_path()))), + (ThreadParamsMode::Cloud, Project(Some(second.path()))), + (ThreadParamsMode::Cloud, Saved("ws~asenvcfg_saved".into())), + (ThreadParamsMode::Cloud, Project(Some(misleading.path()))), + (ThreadParamsMode::Cloud, Project(Some(projectless.path()))), + (ThreadParamsMode::Cloud, Project(None)), + (ThreadParamsMode::Remote, Project(Some(first.path()))), ] { session.thread_params_mode = mode; let result = session - .start_thread_with_session_start_source( + .start_thread_with_environment( &local_settings, &config, /*session_start_source*/ None, /*remote_cwd_override*/ None, /*selected_profile*/ None, - host, + environment, ) .await; assert!(result.unwrap_err().to_string().contains("checkout failed"));