Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Restore approval policy when resuming threads (#37368)

Shijie Rao66225461695f
diff --git a/codex-rs/app-server/README.md b/codex-rs/app-server/README.md
index d05cf4a5cf..5bd8d77099 100644
--- a/codex-rs/app-server/README.md
+++ b/codex-rs/app-server/README.md
@@ -347,7 +347,7 @@ Start a fresh thread when you need a new Codex conversation.
Valid `personality` values are `"friendly"`, `"pragmatic"`, and `"none"`. When `"none"` is selected, the personality placeholder is replaced with an empty string.
-To continue a stored session, call `thread/resume` with the `thread.id` you previously recorded. The response shape matches `thread/start`. When the stored session includes persisted token usage, the server emits `thread/tokenUsage/updated` immediately after the response so clients can render restored usage before the next turn starts. You can also pass the same configuration overrides supported by `thread/start`, including `approvalsReviewer`.
+To continue a stored session, call `thread/resume` with the `thread.id` you previously recorded. The response shape matches `thread/start`. When the stored session includes persisted token usage, the server emits `thread/tokenUsage/updated` immediately after the response so clients can render restored usage before the next turn starts. You can also pass the same configuration overrides supported by `thread/start`, including `approvalsReviewer`. On cold resume, approval policy uses the first allowed value in this order: request override, latest persisted thread setting, current configured default.
By default, `thread/resume` includes the reconstructed turn history in `thread.turns`. Experimental clients can pass `excludeTurns: true` to return only thread metadata and live resume state, then call `thread/turns/list` separately if they want to page the turn history over the network. A cold paginated resume can still replay persisted `thread/tokenUsage/updated` when it can identify the corresponding stored turn; resuming an already-loaded thread waits for the next live update.
diff --git a/codex-rs/app-server/src/request_processors/thread_processor.rs b/codex-rs/app-server/src/request_processors/thread_processor.rs
index 07c9d1755f..a12874fea3 100644
--- a/codex-rs/app-server/src/request_processors/thread_processor.rs
+++ b/codex-rs/app-server/src/request_processors/thread_processor.rs
@@ -194,6 +194,42 @@ fn merge_persisted_approvals_reviewer(
});
}
+fn latest_persisted_approval_policy(
+ history: &[RolloutItem],
+) -> Option<codex_protocol::protocol::AskForApproval> {
+ history
+ .iter()
+ .enumerate()
+ .rev()
+ .find_map(|(index, item)| match item {
+ RolloutItem::TurnContext(turn_context) => {
+ let updated_policy = turn_context.turn_id.as_ref().and_then(|turn_id| {
+ let turn_start = history[..index].iter().rposition(|item| {
+ matches!(
+ item,
+ RolloutItem::EventMsg(EventMsg::TurnStarted(event))
+ if &event.turn_id == turn_id
+ )
+ })?;
+ history[turn_start + 1..index]
+ .iter()
+ .rev()
+ .find_map(|item| match item {
+ RolloutItem::EventMsg(EventMsg::ThreadSettingsApplied(event)) => {
+ Some(event.thread_settings.approval_policy)
+ }
+ _ => None,
+ })
+ });
+ Some(updated_policy.unwrap_or(turn_context.approval_policy))
+ }
+ RolloutItem::EventMsg(EventMsg::ThreadSettingsApplied(event)) => {
+ Some(event.thread_settings.approval_policy)
+ }
+ _ => None,
+ })
+}
+
fn normalize_thread_list_cwd_filters(
cwd: Option<ThreadListCwdFilter>,
) -> Result<Option<Vec<PathBuf>>, JSONRPCErrorError> {
@@ -3190,6 +3226,27 @@ impl ThreadRequestProcessor {
developer_instructions,
personality,
);
+ if typesafe_overrides.approval_policy.is_none()
+ && let Some(value) = request_overrides
+ .as_mut()
+ .and_then(|overrides| overrides.remove("approval_policy"))
+ {
+ let approval_policy = match serde_json::from_value(value) {
+ Ok(approval_policy) => approval_policy,
+ Err(err) => {
+ self.outgoing
+ .send_error(
+ request_id,
+ invalid_params(format!(
+ "invalid `approval_policy` config override: {err}"
+ )),
+ )
+ .await;
+ return Ok(());
+ }
+ };
+ typesafe_overrides.approval_policy = Some(approval_policy);
+ }
let has_explicit_model_resume_override =
has_model_resume_override(request_overrides.as_ref(), &typesafe_overrides);
let persisted_metadata = self
@@ -3470,6 +3527,10 @@ impl ThreadRequestProcessor {
request_overrides.as_ref(),
typesafe_overrides,
);
+ if typesafe_overrides.approval_policy.is_none() {
+ typesafe_overrides.approval_policy =
+ latest_persisted_approval_policy(&resumed_history.history);
+ }
let state_db_ctx = self.state_db.clone()?;
let persisted_metadata = state_db_ctx
.get_thread(resumed_history.conversation_id)
diff --git a/codex-rs/app-server/src/request_processors/thread_processor_tests.rs b/codex-rs/app-server/src/request_processors/thread_processor_tests.rs
index cf491c8f74..33cbd160f4 100644
--- a/codex-rs/app-server/src/request_processors/thread_processor_tests.rs
+++ b/codex-rs/app-server/src/request_processors/thread_processor_tests.rs
@@ -36,6 +36,136 @@ mod thread_list_cwd_filter_tests {
}
}
+mod persisted_resume_approval_policy_tests {
+ use super::super::latest_persisted_approval_policy;
+ use codex_protocol::config_types::ApprovalsReviewer;
+ use codex_protocol::config_types::CollaborationMode;
+ use codex_protocol::config_types::ModeKind;
+ use codex_protocol::config_types::Settings;
+ use codex_protocol::models::PermissionProfile;
+ use codex_protocol::protocol::AskForApproval;
+ use codex_protocol::protocol::EventMsg;
+ use codex_protocol::protocol::RolloutItem;
+ use codex_protocol::protocol::SandboxPolicy;
+ use codex_protocol::protocol::ThreadSettingsAppliedEvent;
+ use codex_protocol::protocol::ThreadSettingsSnapshot;
+ use codex_protocol::protocol::TurnContextItem;
+ use codex_protocol::protocol::TurnStartedEvent;
+ use codex_utils_absolute_path::AbsolutePathBuf;
+ use pretty_assertions::assert_eq;
+
+ fn cwd() -> AbsolutePathBuf {
+ AbsolutePathBuf::try_from(std::env::current_dir().expect("current directory"))
+ .expect("absolute current directory")
+ }
+
+ fn settings_item(approval_policy: AskForApproval) -> RolloutItem {
+ RolloutItem::EventMsg(EventMsg::ThreadSettingsApplied(
+ ThreadSettingsAppliedEvent {
+ thread_settings: ThreadSettingsSnapshot {
+ model: "gpt-5".to_string(),
+ model_provider_id: "openai".to_string(),
+ service_tier: None,
+ approval_policy,
+ approvals_reviewer: ApprovalsReviewer::User,
+ permission_profile: PermissionProfile::read_only(),
+ active_permission_profile: None,
+ cwd: cwd(),
+ reasoning_effort: None,
+ reasoning_summary: None,
+ personality: None,
+ collaboration_mode: CollaborationMode {
+ mode: ModeKind::Default,
+ settings: Settings {
+ model: "gpt-5".to_string(),
+ reasoning_effort: None,
+ developer_instructions: None,
+ },
+ },
+ },
+ },
+ ))
+ }
+
+ fn turn_started_item(turn_id: &str) -> RolloutItem {
+ RolloutItem::EventMsg(EventMsg::TurnStarted(TurnStartedEvent {
+ turn_id: turn_id.to_string(),
+ trace_id: None,
+ started_at: None,
+ model_context_window: None,
+ collaboration_mode_kind: ModeKind::Default,
+ }))
+ }
+
+ fn turn_context_item(turn_id: &str, approval_policy: AskForApproval) -> RolloutItem {
+ RolloutItem::TurnContext(TurnContextItem {
+ turn_id: Some(turn_id.to_string()),
+ cwd: cwd(),
+ workspace_roots: None,
+ current_date: None,
+ timezone: None,
+ approval_policy,
+ approvals_reviewer: None,
+ sandbox_policy: SandboxPolicy::new_read_only_policy(),
+ permission_profile: None,
+ network: None,
+ file_system_sandbox_policy: None,
+ model: "gpt-5".to_string(),
+ comp_hash: None,
+ personality: None,
+ collaboration_mode: None,
+ multi_agent_version: None,
+ multi_agent_mode: None,
+ realtime_active: None,
+ effort: None,
+ summary: codex_protocol::config_types::ReasoningSummary::Auto,
+ })
+ }
+
+ #[test]
+ fn latest_settings_snapshot_wins() {
+ let history = vec![
+ settings_item(AskForApproval::Never),
+ settings_item(AskForApproval::OnRequest),
+ ];
+
+ assert_eq!(
+ latest_persisted_approval_policy(&history),
+ Some(AskForApproval::OnRequest)
+ );
+ }
+
+ #[test]
+ fn settings_applied_during_turn_wins_over_stale_compaction_context() {
+ let history = vec![
+ turn_started_item("turn-1"),
+ settings_item(AskForApproval::Never),
+ turn_context_item("turn-1", AskForApproval::OnRequest),
+ ];
+
+ assert_eq!(
+ latest_persisted_approval_policy(&history),
+ Some(AskForApproval::Never)
+ );
+ }
+
+ #[test]
+ fn later_turn_context_wins_over_earlier_settings_update() {
+ let history = vec![
+ turn_started_item("turn-1"),
+ settings_item(AskForApproval::Never),
+ turn_context_item("turn-1", AskForApproval::OnRequest),
+ turn_started_item("turn-2"),
+ turn_context_item("turn-2", AskForApproval::OnRequest),
+ ];
+
+ assert_eq!(
+ latest_persisted_approval_policy(&history),
+ Some(AskForApproval::OnRequest)
+ );
+ }
+}
+
mod background_terminal_pagination_tests {
use super::super::paginate_background_terminals;
use codex_app_server_protocol::ThreadBackgroundTerminal;
diff --git a/codex-rs/app-server/tests/suite/v2/thread_resume.rs b/codex-rs/app-server/tests/suite/v2/thread_resume.rs
index c6e70c86a4..e6a410fde0 100644
--- a/codex-rs/app-server/tests/suite/v2/thread_resume.rs
+++ b/codex-rs/app-server/tests/suite/v2/thread_resume.rs
@@ -716,6 +716,134 @@ async fn thread_resume_preserves_persisted_approvals_reviewer() -> Result<()> {
Ok(())
}
+#[tokio::test]
+async fn thread_resume_restores_persisted_approval_policy() -> Result<()> {
+ assert_thread_resume_approval_policy(
+ ThreadHistoryMode::Legacy,
+ /*approval_policy*/ None,
+ AskForApproval::Never,
+ )
+ .await
+}
+
+#[tokio::test]
+async fn paginated_thread_resume_restores_persisted_approval_policy() -> Result<()> {
+ assert_thread_resume_approval_policy(
+ ThreadHistoryMode::Paginated,
+ /*approval_policy*/ None,
+ AskForApproval::Never,
+ )
+ .await
+}
+
+#[tokio::test]
+async fn thread_resume_approval_policy_override_wins_over_persisted_policy() -> Result<()> {
+ assert_thread_resume_approval_policy(
+ ThreadHistoryMode::Legacy,
+ Some(AskForApproval::OnRequest),
+ AskForApproval::OnRequest,
+ )
+ .await
+}
+
+async fn assert_thread_resume_approval_policy(
+ history_mode: ThreadHistoryMode,
+ approval_policy: Option<AskForApproval>,
+ expected_approval_policy: AskForApproval,
+) -> Result<()> {
+ let server = create_mock_responses_server_repeating_assistant("Done").await;
+ let codex_home = TempDir::new()?;
+ let config_path = codex_home.path().join("config.toml");
+ std::fs::write(
+ &config_path,
+ format!(
+ r#"
+model = "gpt-5.4"
+approval_policy = "never"
+model_provider = "mock_provider"
+
+[model_providers.mock_provider]
+name = "Mock provider for test"
+base_url = "{}/v1"
+wire_api = "responses"
+request_max_retries = 0
+stream_max_retries = 0
+"#,
+ server.uri()
+ ),
+ )?;
+
+ let thread_id = {
+ let mut mcp = TestAppServer::builder()
+ .with_codex_home(codex_home.path())
+ .without_auto_env()
+ .build_initialized()
+ .await?;
+
+ let start_id = mcp
+ .send_thread_start_request(ThreadStartParams {
+ model: Some("gpt-5.4".to_string()),
+ history_mode: Some(history_mode),
+ ..Default::default()
+ })
+ .await?;
+ let ThreadStartResponse { thread, .. } =
+ timeout(DEFAULT_READ_TIMEOUT, mcp.read_response(start_id)).await??;
+
+ let turn_id = mcp
+ .send_turn_start_request(TurnStartParams {
+ thread_id: thread.id.clone(),
+ client_user_message_id: None,
+ input: vec![UserInput::Text {
+ text: "materialize this thread".to_string(),
+ text_elements: Vec::new(),
+ }],
+ ..Default::default()
+ })
+ .await?;
+ timeout(
+ DEFAULT_READ_TIMEOUT,
+ mcp.read_stream_until_response_message(RequestId::Integer(turn_id)),
+ )
+ .await??;
+ timeout(
+ DEFAULT_READ_TIMEOUT,
+ mcp.read_stream_until_notification_message("turn/completed"),
+ )
+ .await??;
+
+ thread.id
+ };
+
+ let config = std::fs::read_to_string(&config_path)?;
+ std::fs::write(
+ config_path,
+ config.replace(
+ "approval_policy = \"never\"",
+ "approval_policy = \"on-request\"",
+ ),
+ )?;
+
+ let mut mcp = TestAppServer::builder()
+ .with_codex_home(codex_home.path())
+ .without_auto_env()
+ .build_initialized()
+ .await?;
+ let resume_id = mcp
+ .send_thread_resume_request(ThreadResumeParams {
+ thread_id,
+ approval_policy,
+ ..Default::default()
+ })
+ .await?;
+ let ThreadResumeResponse {
+ approval_policy, ..
+ } = timeout(DEFAULT_READ_TIMEOUT, mcp.read_response(resume_id)).await??;
+
+ assert_eq!(approval_policy, expected_approval_policy);
+ Ok(())
+}
+
#[tokio::test]
async fn thread_resume_preserves_goal_first_and_fork_approvals_reviewer() -> Result<()> {
let server = create_mock_responses_server_repeating_assistant("Done").await;