Lightweight coding agent that runs in your terminal
Rust
Enforce current provider requirements for the model catalog (#46917)
alexsong-oai75db67bbc6a1
diff --git a/codex-rs/app-server/README.md b/codex-rs/app-server/README.mdindex 89558ac889..5206ea6368 100644--- a/codex-rs/app-server/README.md+++ b/codex-rs/app-server/README.md@@ -1,3 +1,12 @@+# Model catalog provider requirements++`model/list` and periodic model catalog refreshes check the startup provider against+current managed provider requirements before using the catalog. If that provider no longer+complies, `model/list` returns JSON-RPC error `-32600` asking the client to restart Codex,+and background refreshes skip the old endpoint. Requirement load failures also block these+operations. Checks apply even when the catalog is cached. Existing startup provider selection+and caching behavior remain in effect while the provider satisfies current requirements.+# MCP App UI`mcpToolCall.mcpAppUi` records the invoked descriptor's `resourceUri`diff --git a/codex-rs/app-server/src/lib.rs b/codex-rs/app-server/src/lib.rsindex e0149fa3ce..fc11b838a0 100644--- a/codex-rs/app-server/src/lib.rs+++ b/codex-rs/app-server/src/lib.rs@@ -120,6 +120,7 @@ mod image_url;pub mod in_process;mod mcp_refresh;mod message_processor;+mod model_catalog;mod models;mod models_refresh_worker;mod notification_media;diff --git a/codex-rs/app-server/src/message_processor.rs b/codex-rs/app-server/src/message_processor.rsindex 7bc5c527de..118106d710 100644--- a/codex-rs/app-server/src/message_processor.rs+++ b/codex-rs/app-server/src/message_processor.rs@@ -370,9 +370,12 @@ impl MessageProcessor {None => manager,}});- let models_manager = thread_manager.get_models_manager();- let models_refresh_worker =- crate::models_refresh_worker::spawn(&models_manager, config.http_client_factory());+ let model_catalog = Arc::new(crate::model_catalog::ModelCatalog::new(+ config_manager.clone(),+ Arc::clone(&config),+ thread_manager.get_models_manager(),+ ));+ let models_refresh_worker = crate::models_refresh_worker::spawn(&model_catalog);let turn_cost_worker =TurnCostWorker::spawn(Arc::clone(&config), Arc::clone(&auth_manager));thread_manager@@ -424,6 +427,7 @@ impl MessageProcessor {Arc::clone(&thread_manager),Arc::clone(&config),config_manager.clone(),+ model_catalog,);let command_exec_processor = CommandExecRequestProcessor::new(arg0_paths.clone(),diff --git a/codex-rs/app-server/src/model_catalog.rs b/codex-rs/app-server/src/model_catalog.rsnew file mode 100644index 0000000000..54d7ff8501--- /dev/null+++ b/codex-rs/app-server/src/model_catalog.rs@@ -0,0 +1,46 @@+//! Gates access to the retained startup model catalog on current managed provider requirements.++use std::sync::Arc;++use codex_core::config::Config;+use codex_models_manager::manager::RefreshStrategy;+use codex_models_manager::manager::SharedModelsManager;+use codex_protocol::openai_models::ModelPreset;++use crate::config_manager::ConfigManager;++/// Checks the retained catalog route before model/list and background refreshes.+pub(crate) struct ModelCatalog {+ config_manager: ConfigManager,+ config: Arc<Config>,+ models_manager: SharedModelsManager,+}++impl ModelCatalog {+ pub(crate) fn new(+ config_manager: ConfigManager,+ config: Arc<Config>,+ models_manager: SharedModelsManager,+ ) -> Self {+ Self {+ config_manager,+ config,+ models_manager,+ }+ }++ pub(crate) async fn list_models(+ &self,+ refresh_strategy: RefreshStrategy,+ ) -> std::io::Result<Vec<ModelPreset>> {+ // Check before consulting even a warm cache, just as turn admission checks+ // the retained session route before using it.+ self.config_manager+ .check_thread_model_provider(&self.config)+ .await?;+ Ok(self+ .models_manager+ .list_models(refresh_strategy, self.config.http_client_factory())+ .await)+ }+}diff --git a/codex-rs/app-server/src/models.rs b/codex-rs/app-server/src/models.rsindex b42c8bccaf..b9f2720589 100644--- a/codex-rs/app-server/src/models.rs+++ b/codex-rs/app-server/src/models.rs@@ -1,23 +1,12 @@-use std::sync::Arc;-use codex_app_server_protocol::Model;use codex_app_server_protocol::ModelServiceTier;use codex_app_server_protocol::ModelUpgradeInfo;use codex_app_server_protocol::ReasoningEffortOption;-use codex_core::ThreadManager;-use codex_http_client::HttpClientFactory;-use codex_models_manager::manager::RefreshStrategy;use codex_protocol::openai_models::ModelPreset;use codex_protocol::openai_models::ReasoningEffortPreset;-pub async fn supported_models(- thread_manager: Arc<ThreadManager>,- include_hidden: bool,- http_client_factory: HttpClientFactory,-) -> Vec<Model> {- thread_manager- .list_models(RefreshStrategy::OnlineIfUncached, http_client_factory)- .await+pub fn supported_models(models: Vec<ModelPreset>, include_hidden: bool) -> Vec<Model> {+ models.into_iter().filter(|preset| include_hidden || preset.show_in_picker).map(model_from_preset)diff --git a/codex-rs/app-server/src/models_refresh_worker.rs b/codex-rs/app-server/src/models_refresh_worker.rsindex e57abcc938..794aa7f4d1 100644--- a/codex-rs/app-server/src/models_refresh_worker.rs+++ b/codex-rs/app-server/src/models_refresh_worker.rs@@ -1,12 +1,12 @@use std::sync::Arc;use std::time::Duration;-use codex_http_client::HttpClientFactory;use codex_models_manager::manager::RefreshStrategy;-use codex_models_manager::manager::SharedModelsManager;use tokio::task::JoinHandle;use tokio_util::sync::CancellationToken;+use crate::model_catalog::ModelCatalog;+const MODELS_REFRESH_INTERVAL: Duration = Duration::from_secs(4 * 60 + 30);#[derive(Debug)]@@ -27,19 +27,15 @@ impl Drop for ModelsRefreshWorker {}}-pub(crate) fn spawn(- models_manager: &SharedModelsManager,- http_client_factory: HttpClientFactory,-) -> ModelsRefreshWorker {- spawn_with_interval(models_manager, http_client_factory, MODELS_REFRESH_INTERVAL)+pub(crate) fn spawn(model_catalog: &Arc<ModelCatalog>) -> ModelsRefreshWorker {+ spawn_with_interval(model_catalog, MODELS_REFRESH_INTERVAL)}fn spawn_with_interval(- models_manager: &SharedModelsManager,- http_client_factory: HttpClientFactory,+ model_catalog: &Arc<ModelCatalog>,refresh_interval: Duration,) -> ModelsRefreshWorker {- let models_manager = Arc::downgrade(models_manager);+ let model_catalog = Arc::downgrade(model_catalog);let shutdown = CancellationToken::new();let worker_shutdown = shutdown.clone();let task = tokio::spawn(async move {@@ -47,13 +43,14 @@ fn spawn_with_interval(if worker_shutdown.is_cancelled() {break;}- let Some(models_manager) = models_manager.upgrade() else {+ let Some(model_catalog) = model_catalog.upgrade() else {break;};- models_manager- .list_models(RefreshStrategy::Online, http_client_factory.clone())- .await;- drop(models_manager);+ if let Err(err) = model_catalog.list_models(RefreshStrategy::Online).await {+ // Parser diagnostics can include provider credentials from the source TOML.+ tracing::warn!(error_kind = ?err.kind(), "model catalog refresh blocked by provider requirements");+ }+ drop(model_catalog);tokio::select! {_ = worker_shutdown.cancelled() => break,diff --git a/codex-rs/app-server/src/models_refresh_worker_tests.rs b/codex-rs/app-server/src/models_refresh_worker_tests.rsindex 0a7e132407..5356eb2af3 100644--- a/codex-rs/app-server/src/models_refresh_worker_tests.rs+++ b/codex-rs/app-server/src/models_refresh_worker_tests.rs@@ -3,8 +3,14 @@ use std::sync::atomic::AtomicUsize;use std::sync::atomic::Ordering;use std::time::Duration;+use codex_config::CloudConfigBundle;+use codex_config::CloudConfigBundleLoader;+use codex_config::LoaderOverrides;+use codex_config::test_support::CloudConfigBundleFixture;+use codex_core::config::ConfigBuilder;+use codex_core::config::ConfigOverrides;+use codex_feedback::CodexFeedback;use codex_http_client::HttpClientFactory;-use codex_http_client::OutboundProxyPolicy;use codex_models_manager::manager::ModelsEndpointClient;use codex_models_manager::manager::ModelsEndpointFuture;use codex_models_manager::manager::ModelsEndpointResponse;@@ -15,6 +21,9 @@ use codex_protocol::error::Result as CoreResult;use pretty_assertions::assert_eq;use tempfile::tempdir;use tokio::sync::Notify;+use tokio::sync::mpsc;+use tokio::sync::oneshot;+use tracing_subscriber::layer::SubscriberExt;use super::*;@@ -85,16 +94,36 @@ impl ModelsEndpointClient for TestModelsEndpoint {async fn refreshes_immediately_periodically_and_stops_when_dropped() {let codex_home = tempdir().expect("temp dir");let endpoint = TestModelsEndpoint::new();+ let requirements_path = codex_home.path().join("requirements.toml");+ std::fs::write(&requirements_path, "model_provider = 'ollama'").unwrap();+ let config_manager = crate::config_manager::ConfigManager::new_for_tests(+ codex_home.path().to_path_buf(),+ Vec::new(),+ LoaderOverrides::with_managed_config_path_for_tests(+ codex_home.path().join("managed_config.toml"),+ ),+ CloudConfigBundleLoader::default(),+ );+ // --oss selects the provider through typed overrides, outside ConfigManager's raw -c flags.+ let config = Arc::new(+ ConfigBuilder::default()+ .codex_home(codex_home.path().to_path_buf())+ .loader_overrides(LoaderOverrides::without_managed_config_for_tests())+ .harness_overrides(ConfigOverrides {+ model_provider: Some("ollama".to_string()),+ ..Default::default()+ })+ .build()+ .await+ .unwrap(),+ );let models_manager: SharedModelsManager = Arc::new(OpenAiModelsManager::new(codex_home.path().to_path_buf(),endpoint.clone(),/*auth_manager*/ None,));- let worker = spawn_with_interval(- &models_manager,- HttpClientFactory::new(OutboundProxyPolicy::ReqwestDefault),- Duration::from_millis(10),- );+ let catalog = Arc::new(ModelCatalog::new(config_manager, config, models_manager));+ let worker = spawn_with_interval(&catalog, Duration::from_millis(/*millis*/ 10));endpoint.wait_for_fetch_count(/*expected*/ 2).await;drop(worker);@@ -102,4 +131,101 @@ async fn refreshes_immediately_periodically_and_stops_when_dropped() {tokio::time::sleep(Duration::from_millis(30)).await;assert_eq!(endpoint.fetch_count.load(Ordering::SeqCst), 2);++ // Reloading config would select the newly required provider. The catalog must+ // keep validating the typed startup selection, even when only reading its cache.+ std::fs::write(&requirements_path, "model_provider = 'openai'").unwrap();+ let error = catalog+ .list_models(RefreshStrategy::Offline)+ .await+ .unwrap_err();+ assert_eq!(error.kind(), std::io::ErrorKind::PermissionDenied);+ assert!(+ error+ .get_ref()+ .unwrap()+ .is::<crate::config_manager::ModelProviderRequirementsChanged>()+ );+ assert_eq!(endpoint.fetch_count.load(Ordering::SeqCst), 2);+}++#[tokio::test]+async fn background_refresh_blocks_changed_and_invalid_requirements_then_recovers()+-> anyhow::Result<()> {+ let home = tempdir()?;+ let config = Arc::new(+ crate::config_manager::ConfigManager::without_managed_config_for_tests(+ home.path().to_path_buf(),+ )+ .load_non_project_config()+ .await?,+ );+ let (checks_tx, mut checks_rx) = mpsc::unbounded_channel();+ let loader = CloudConfigBundleLoader::from_getter(move || {+ let (reply_tx, reply_rx) = oneshot::channel::<Option<CloudConfigBundle>>();+ checks_tx+ .send(reply_tx)+ .expect("requirements check receiver");+ async move { Ok(reply_rx.await.expect("requirements check response")) }+ });+ let config_manager = crate::config_manager::ConfigManager::new_for_tests(+ home.path().to_path_buf(),+ Vec::new(),+ LoaderOverrides::without_managed_config_for_tests(),+ loader,+ );+ let endpoint = TestModelsEndpoint::new();+ let models_manager: SharedModelsManager = Arc::new(OpenAiModelsManager::new(+ home.path().to_path_buf(),+ endpoint.clone(),+ /*auth_manager*/ None,+ ));+ let catalog = Arc::new(ModelCatalog::new(config_manager, config, models_manager));+ let feedback = CodexFeedback::new();+ // This test uses Tokio's current-thread runtime, so spawned refreshes share the subscriber.+ let _subscriber_guard = tracing::subscriber::set_default(+ tracing_subscriber::registry().with(feedback.logger_layer()),+ );+ let worker = spawn_with_interval(&catalog, Duration::from_millis(/*millis*/ 10));+ tokio::time::timeout(Duration::from_secs(/*secs*/ 10), async {+ for expected in 1..=2 {+ checks_rx.recv().await.unwrap().send(/*t*/ None).unwrap();+ endpoint.wait_for_fetch_count(expected).await;+ }++ // Let the in-flight request finish, then control each refresh's requirements.+ endpoint.release_second_fetch.notify_one();+ let mut next_check = checks_rx.recv().await.unwrap();+ for requirements in [+ "model_provider = 'other'",+ "model_provider = []",+ "[model_providers.gateway]\nexperimental_bearer_token = 'private-provider-token-marker' trailing",+ ] {+ next_check+ .send(Some(+ CloudConfigBundleFixture::enterprise_requirement(requirements).into_bundle(),+ ))+ .unwrap();+ // Reaching the next check proves the previous refresh completed. Keep+ // this check blocked while asserting that the previous one did not fetch.+ next_check = checks_rx.recv().await.unwrap();+ assert_eq!(endpoint.fetch_count.load(Ordering::SeqCst), 2);+ }++ next_check.send(/*t*/ None).unwrap();+ endpoint.wait_for_fetch_count(/*expected*/ 3).await;+ })+ .await?;+ drop(worker);+ let logs = String::from_utf8(+ feedback+ .snapshot(/*session_id*/ None)+ .log_attachment(/*logs_override*/ None)+ .buffer,+ )?;+ assert!(logs.contains("model catalog refresh blocked by provider requirements"));+ assert!(logs.contains("error_kind=PermissionDenied"));+ assert!(logs.contains("error_kind=InvalidData"));+ assert!(!logs.contains("private-provider-token-marker"));+ Ok(())}diff --git a/codex-rs/app-server/src/request_processors/catalog_processor.rs b/codex-rs/app-server/src/request_processors/catalog_processor.rsindex 45b8f132ff..cc11ef8737 100644--- a/codex-rs/app-server/src/request_processors/catalog_processor.rs+++ b/codex-rs/app-server/src/request_processors/catalog_processor.rs@@ -1,4 +1,5 @@use super::*;+use crate::model_catalog::ModelCatalog;use codex_config::ConfigPathContext;use codex_core::config::permission_profile_catalog;use codex_hooks::HookListEntryHandler;@@ -14,6 +15,7 @@ pub(crate) struct CatalogRequestProcessor {pub(super) thread_manager: Arc<ThreadManager>,pub(super) config: Arc<Config>,pub(super) config_manager: ConfigManager,+ model_catalog: Arc<ModelCatalog>,}const SKILLS_LIST_CWD_CONCURRENCY: usize = 5;@@ -124,6 +126,7 @@ impl CatalogRequestProcessor {thread_manager: Arc<ThreadManager>,config: Arc<Config>,config_manager: ConfigManager,+ model_catalog: Arc<ModelCatalog>,) -> Self {Self {outgoing,@@ -131,6 +134,7 @@ impl CatalogRequestProcessor {thread_manager,config,config_manager,+ model_catalog,}}@@ -174,13 +178,9 @@ impl CatalogRequestProcessor {&self,params: ModelListParams,) -> Result<Option<ClientResponsePayload>, JSONRPCErrorError> {- Self::list_models(- self.thread_manager.clone(),- self.config.http_client_factory(),- params,- )- .await- .map(|response| Some(response.into()))+ self.list_models(params)+ .await+ .map(|response| Some(response.into()))}pub(crate) async fn experimental_feature_list(@@ -245,8 +245,7 @@ impl CatalogRequestProcessor {}async fn list_models(- thread_manager: Arc<ThreadManager>,- http_client_factory: codex_http_client::HttpClientFactory,+ &self,params: ModelListParams,) -> Result<ModelListResponse, JSONRPCErrorError> {let ModelListParams {@@ -254,12 +253,12 @@ impl CatalogRequestProcessor {cursor,include_hidden,} = params;- let models = supported_models(- thread_manager,- include_hidden.unwrap_or(false),- http_client_factory,- )- .await;+ let presets = self+ .model_catalog+ .list_models(codex_models_manager::manager::RefreshStrategy::OnlineIfUncached)+ .await+ .map_err(|err| config_load_error(&err))?;+ let models = supported_models(presets, include_hidden.unwrap_or(false));let total = models.len();if total == 0 {diff --git a/codex-rs/app-server/tests/suite/v2/mod.rs b/codex-rs/app-server/tests/suite/v2/mod.rsindex 91c6ddab00..0ea66030c1 100644--- a/codex-rs/app-server/tests/suite/v2/mod.rs+++ b/codex-rs/app-server/tests/suite/v2/mod.rs@@ -74,6 +74,7 @@ mod memory_reset;mod misalignment_policy;mod model_auto_review;mod model_list;+mod model_list_requirements_tests;mod model_provider_capabilities_read;#[path = "model_provider_enforcement_tests.rs"]mod model_provider_enforcement;diff --git a/codex-rs/app-server/tests/suite/v2/model_list_requirements_tests.rs b/codex-rs/app-server/tests/suite/v2/model_list_requirements_tests.rsnew file mode 100644index 0000000000..77964124dd--- /dev/null+++ b/codex-rs/app-server/tests/suite/v2/model_list_requirements_tests.rs@@ -0,0 +1,205 @@+//! Exercises live catalog routing through the public model/list RPC.++use anyhow::Result;+use app_test_support::ChatGptAuthFixture;+use app_test_support::TestAppServer;+use app_test_support::write_chatgpt_auth;+use codex_app_server_protocol::ClientRequest;+use codex_app_server_protocol::ModelListParams;+use codex_app_server_protocol::ModelListResponse;+use codex_app_server_protocol::RequestId;+use codex_config::types::AuthCredentialsStoreMode;+use codex_protocol::openai_models::ModelInfo;+use codex_protocol::openai_models::ModelsResponse;+use core_test_support::responses::mount_models_once;+use pretty_assertions::assert_eq;+use serde_json::json;+use std::time::Duration;+use tempfile::TempDir;+use test_case::test_case;+use wiremock::MockServer;++fn catalog(slug: &str) -> Result<ModelsResponse> {+ Ok(ModelsResponse {+ models: vec![serde_json::from_value::<ModelInfo>(json!({+ "slug": slug,+ "display_name": slug,+ "supported_reasoning_levels": [],+ "shell_type": "shell_command",+ "visibility": "list",+ "supported_in_api": true,+ "priority": 0,+ "support_verbosity": false,+ "truncation_policy": {"mode": "bytes", "limit": 10000},+ "experimental_supported_tools": []+ }))?],+ })+}++async fn list_models(server: &mut TestAppServer) -> Result<ModelListResponse> {+ server+ .request(|request_id| ClientRequest::ModelList {+ request_id,+ params: ModelListParams::default(),+ })+ .await+}++#[test_case("other"; "selection_changes")]+#[test_case("gateway"; "definition_changes")]+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn model_list_blocks_noncompliant_cached_provider_until_requirements_allow_it(+ required_selection: &str,+) -> Result<()> {+ let gateway = MockServer::start().await;+ let other = MockServer::start().await;+ mount_models_once(&gateway, catalog("gateway-model")?).await;+ mount_models_once(&other, catalog("other-model")?).await;+ let home = TempDir::new()?;+ let providers = format!(+ r#"+[model_providers.gateway]+name = "Gateway"+base_url = "{}/v1"+requires_openai_auth = true+[model_providers.other]+name = "Other"+base_url = "{}/v1"+requires_openai_auth = true+"#,+ gateway.uri(),+ other.uri(),+ );+ std::fs::write(+ home.path().join("config.toml"),+ format!("model_provider = 'gateway'\n{providers}"),+ )?;+ write_chatgpt_auth(+ home.path(),+ ChatGptAuthFixture::new("chatgpt-access-token").plan_type("pro"),+ AuthCredentialsStoreMode::File,+ )?;+ let requirements_path = home.path().join("requirements.toml");+ std::fs::write(+ &requirements_path,+ format!("model_provider = 'gateway'\n{providers}"),+ )?;+ let mut server = TestAppServer::builder()+ .with_codex_home(home.path())+ .with_env_overrides(&[("OPENAI_API_KEY", None)])+ .build_initialized()+ .await?;++ // Let the startup refresh populate the cache before exercising cached RPCs.+ tokio::time::timeout(Duration::from_secs(/*secs*/ 10), async {+ loop {+ if let Ok(bytes) = tokio::fs::read(home.path().join("models_cache.json")).await+ && let Ok(cache) = serde_json::from_slice::<serde_json::Value>(&bytes)+ && cache["models"][0]["slug"] == "gateway-model"+ {+ break;+ }+ tokio::time::sleep(Duration::from_millis(/*millis*/ 10)).await;+ }+ })+ .await?;++ let initial = list_models(&mut server).await?;+ assert_eq!(+ initial+ .data+ .iter()+ .map(|model| model.id.as_str())+ .collect::<Vec<_>>(),+ vec!["gateway-model"]+ );+ assert_eq!(list_models(&mut server).await?, initial);+ assert_eq!(+ gateway+ .received_requests()+ .await+ .expect("request recording enabled")+ .len(),+ 1+ );+ assert!(+ other+ .received_requests()+ .await+ .expect("request recording enabled")+ .is_empty()+ );++ let updated_providers = if required_selection == "gateway" {+ providers.replace(&gateway.uri(), &other.uri())+ } else {+ providers.clone()+ };+ let updated = format!("model_provider = '{required_selection}'\n{updated_providers}");+ std::fs::write(&requirements_path, &updated)?;+ let id = server+ .send_raw_request("model/list", Some(json!({})))+ .await?;+ let error = server+ .read_stream_until_error_message(RequestId::Integer(id))+ .await?;+ assert_eq!(error.error, codex_app_server_protocol::JSONRPCErrorError {+ code: -32600,+ message: "failed to load configuration: Your organization's required model provider settings changed. Restart Codex to apply them; this request was not sent".to_string(),+ data: None,+ });+ assert_eq!(+ gateway+ .received_requests()+ .await+ .expect("request recording enabled")+ .len(),+ 1+ );+ assert!(+ other+ .received_requests()+ .await+ .expect("request recording enabled")+ .is_empty()+ );++ // A warm catalog must not hide a policy load failure or make any stale request.+ std::fs::write(&requirements_path, "model_provider = []")?;+ let id = server+ .send_raw_request("model/list", Some(json!({})))+ .await?;+ let error = server+ .read_stream_until_error_message(RequestId::Integer(id))+ .await?;+ assert_eq!(error.error.code, -32600);+ assert!(error.error.message.contains("failed to load configuration"));+ assert_eq!(+ gateway+ .received_requests()+ .await+ .expect("request recording enabled")+ .len(),+ 1+ );+ assert!(+ other+ .received_requests()+ .await+ .expect("request recording enabled")+ .is_empty()+ );++ // Removing the requirement makes the retained provider permissible again.+ std::fs::remove_file(requirements_path)?;+ assert_eq!(list_models(&mut server).await?, initial);+ assert_eq!(+ gateway+ .received_requests()+ .await+ .expect("request recording enabled")+ .len(),+ 1+ );+ Ok(())+}diff --git a/codex-rs/app-server/tests/suite/v2/thread_start.rs b/codex-rs/app-server/tests/suite/v2/thread_start.rsindex 1a971b0e6c..00f25e78d2 100644--- a/codex-rs/app-server/tests/suite/v2/thread_start.rs+++ b/codex-rs/app-server/tests/suite/v2/thread_start.rs@@ -52,6 +52,7 @@ use serde_json::json;use std::path::Path;use std::path::PathBuf;use tempfile::TempDir;+use test_case::test_case;use tokio::net::TcpListener;use tokio::sync::oneshot;use tokio::time::timeout;@@ -1416,8 +1417,12 @@ async fn thread_start_does_not_wait_for_optional_http_mcp_auth_discovery() -> ReOk(())}+#[test_case("thread/start"; "thread_start")]+#[test_case("model/list"; "model_list")]#[tokio::test]-async fn thread_start_surfaces_cloud_config_bundle_load_errors() -> Result<()> {+async fn config_requests_surface_cloud_config_bundle_load_errors(+ request_method: &str,+) -> Result<()> {let server = MockServer::start().await;Mock::given(method("GET")).and(path("/backend-api/wham/config/bundle"))@@ -1468,9 +1473,13 @@ async fn thread_start_surfaces_cloud_config_bundle_load_errors() -> Result<()> {.build_initialized().await?;- let req_id = mcp- .send_thread_start_request_with_auto_env(ThreadStartParams::default())- .await?;+ let req_id = if request_method == "thread/start" {+ mcp.send_thread_start_request_with_auto_env(ThreadStartParams::default())+ .await?+ } else {+ mcp.send_raw_request(request_method, Some(json!({})))+ .await?+ };let err: JSONRPCError = timeout(DEFAULT_READ_TIMEOUT,