Tighten turn environment MCP semantics

Use turn-local environments for pending MCP refreshes, keep disabled-environment sessions startable when no MCP servers are enabled, and reject ambiguous cwd plus explicit environment updates.

Co-authored-by: Codex <noreply@openai.com>
This commit is contained in:
starr-openai
2026-04-30 16:19:01 -07:00
co-authored by Codex
parent 56f259e8ec
commit fddf257b83
5 changed files with 107 additions and 85 deletions
+48 -24
View File
@@ -1,6 +1,30 @@
use super::*;
impl Session {
pub(crate) fn fallback_mcp_runtime_environment(
&self,
fallback_cwd: &AbsolutePathBuf,
require_default_environment: bool,
) -> CodexResult<McpRuntimeEnvironment> {
if let Some(default_environment) = self.services.environment_manager.default_environment() {
return Ok(McpRuntimeEnvironment::new(
default_environment,
fallback_cwd.to_path_buf(),
));
}
if require_default_environment {
return Err(CodexErr::InvalidRequest(
"MCP runtime environment requires a default environment".to_string(),
));
}
Ok(McpRuntimeEnvironment::new(
self.services.environment_manager.local_environment(),
fallback_cwd.to_path_buf(),
))
}
pub(crate) fn mcp_runtime_environment_for_configuration(
&self,
session_configuration: &SessionConfiguration,
@@ -25,20 +49,22 @@ impl Session {
));
}
let default_environment = self
.services
.environment_manager
.default_environment()
.ok_or_else(|| {
CodexErr::InvalidRequest(
"MCP runtime environment requires a default environment".to_string(),
)
})?;
self.fallback_mcp_runtime_environment(&session_configuration.cwd, true)
}
Ok(McpRuntimeEnvironment::new(
default_environment,
session_configuration.cwd.to_path_buf(),
))
pub(crate) fn mcp_runtime_environment_for_turn_context(
&self,
turn_context: &TurnContext,
require_default_environment: bool,
) -> CodexResult<McpRuntimeEnvironment> {
if let Some(turn_environment) = turn_context.primary_environment() {
return Ok(McpRuntimeEnvironment::new(
Arc::clone(&turn_environment.environment),
turn_environment.cwd.to_path_buf(),
));
}
self.fallback_mcp_runtime_environment(&turn_context.cwd, require_default_environment)
}
#[expect(
@@ -261,18 +287,16 @@ impl Session {
let mcp_servers = with_codex_apps_mcp(mcp_servers, auth.as_ref(), &mcp_config);
let auth_statuses =
compute_auth_statuses(mcp_servers.iter(), store_mode, auth.as_ref()).await;
let session_configuration = {
let state = self.state.lock().await;
state.session_configuration.clone()
let enabled_mcp_server_count = mcp_servers.values().filter(|server| server.enabled).count();
let mcp_runtime_environment = match self
.mcp_runtime_environment_for_turn_context(turn_context, enabled_mcp_server_count > 0)
{
Ok(runtime_environment) => runtime_environment,
Err(err) => {
warn!("failed to resolve MCP runtime environment for refresh: {err}");
return;
}
};
let mcp_runtime_environment =
match self.mcp_runtime_environment_for_configuration(&session_configuration) {
Ok(runtime_environment) => runtime_environment,
Err(err) => {
warn!("failed to resolve MCP runtime environment for refresh: {err}");
return;
}
};
{
let mut guard = self.services.mcp_startup_cancellation_token.lock().await;
guard.cancel();
+17 -2
View File
@@ -1,5 +1,6 @@
use super::*;
use crate::goals::GoalRuntimeState;
use codex_config::ConstraintError;
use codex_protocol::permissions::FileSystemPath;
use codex_protocol::permissions::FileSystemSpecialPath;
use codex_protocol::protocol::TurnEnvironmentSelection;
@@ -145,6 +146,12 @@ impl SessionConfiguration {
}
pub(crate) fn apply(&self, updates: &SessionSettingsUpdate) -> ConstraintResult<Self> {
if updates.cwd.is_some() && updates.environments.is_some() {
return Err(ConstraintError::invalid_combination(
"`cwd` cannot be updated together with turn-local `environments`",
));
}
let mut next_configuration = self.clone();
let current_sandbox_policy = self.sandbox_policy();
let current_file_system_sandbox_policy = self.file_system_sandbox_policy();
@@ -925,8 +932,16 @@ impl Session {
cancel_guard.cancel();
*cancel_guard = CancellationToken::new();
}
let mcp_runtime_environment =
sess.mcp_runtime_environment_for_configuration(&session_configuration)?;
let mcp_runtime_environment = match sess
.mcp_runtime_environment_for_configuration(&session_configuration)
{
Ok(runtime_environment) => runtime_environment,
Err(_) if enabled_mcp_server_count == 0 => sess.fallback_mcp_runtime_environment(
&session_configuration.cwd,
/*require_default_environment*/ false,
)?,
Err(err) => return Err(err.into()),
};
let (mcp_connection_manager, cancel_token) = McpConnectionManager::new(
&mcp_servers,
config.mcp_oauth_credentials_store_mode,
+19 -27
View File
@@ -3331,9 +3331,9 @@ async fn relative_cwd_update_without_environments_resolves_under_session_cwd() {
}
#[tokio::test]
async fn relative_cwd_update_with_turn_environment_keeps_turn_environment_cwd() {
async fn relative_cwd_update_with_turn_environment_is_rejected() {
let (session, _turn_context, _rx) = make_session_and_context_with_rx().await;
let (stored_cwd, turn_environment_cwd, expected_session_cwd) = {
let (stored_cwd, turn_environment_cwd) = {
let mut state = session.state.lock().await;
let stored_cwd = state.session_configuration.cwd.clone();
let stored_environment_cwd = stored_cwd.join("stored-environment");
@@ -3342,12 +3342,12 @@ async fn relative_cwd_update_with_turn_environment_keeps_turn_environment_cwd()
environment_id: codex_exec_server::LOCAL_ENVIRONMENT_ID.to_string(),
cwd: stored_environment_cwd,
}];
let expected_session_cwd = turn_environment_cwd.join("project");
(stored_cwd, turn_environment_cwd, expected_session_cwd)
(stored_cwd, turn_environment_cwd)
};
std::fs::create_dir_all(expected_session_cwd.as_path()).expect("create project dir");
std::fs::create_dir_all(turn_environment_cwd.join("project").as_path())
.expect("create project dir");
let turn_context = session
let err = session
.new_turn_with_sub_id(
"sub-1".to_string(),
SessionSettingsUpdate {
@@ -3360,40 +3360,33 @@ async fn relative_cwd_update_with_turn_environment_keeps_turn_environment_cwd()
},
)
.await
.expect("turn should start");
.expect_err("cwd and explicit environments should be rejected");
let state = session.state.lock().await;
assert_eq!(state.session_configuration.cwd, expected_session_cwd);
assert!(matches!(err, CodexErr::InvalidRequest(_)));
assert!(err.to_string().contains("cannot be updated together"));
assert_eq!(state.session_configuration.cwd, stored_cwd);
assert_eq!(
state.session_configuration.environments[0].cwd,
stored_cwd.join("stored-environment")
);
assert_eq!(turn_context.cwd, turn_environment_cwd);
assert_eq!(
turn_context
.primary_environment()
.expect("primary environment")
.cwd,
turn_environment_cwd
);
}
#[tokio::test]
async fn relative_cwd_update_with_empty_turn_environments_resolves_under_session_cwd() {
async fn relative_cwd_update_with_empty_turn_environments_is_rejected() {
let (session, _turn_context, _rx) = make_session_and_context_with_rx().await;
let (stored_cwd, expected_cwd) = {
let stored_cwd = {
let mut state = session.state.lock().await;
let stored_cwd = state.session_configuration.cwd.clone();
state.session_configuration.environments = vec![TurnEnvironmentSelection {
environment_id: codex_exec_server::LOCAL_ENVIRONMENT_ID.to_string(),
cwd: stored_cwd.join("stored-environment"),
}];
let expected_cwd = stored_cwd.join("project");
(stored_cwd, expected_cwd)
stored_cwd
};
std::fs::create_dir_all(expected_cwd.as_path()).expect("create project dir");
std::fs::create_dir_all(stored_cwd.join("project").as_path()).expect("create project dir");
let turn_context = session
let err = session
.new_turn_with_sub_id(
"sub-1".to_string(),
SessionSettingsUpdate {
@@ -3403,17 +3396,16 @@ async fn relative_cwd_update_with_empty_turn_environments_resolves_under_session
},
)
.await
.expect("turn should start");
.expect_err("cwd and explicit empty environments should be rejected");
let state = session.state.lock().await;
assert_eq!(state.session_configuration.cwd, expected_cwd);
assert!(matches!(err, CodexErr::InvalidRequest(_)));
assert!(err.to_string().contains("cannot be updated together"));
assert_eq!(state.session_configuration.cwd, stored_cwd);
assert_eq!(
state.session_configuration.environments[0].cwd,
stored_cwd.join("stored-environment")
);
assert_eq!(turn_context.cwd, expected_cwd);
assert!(turn_context.primary_environment().is_none());
assert!(turn_context.environments.is_empty());
}
#[tokio::test]