From 75e79cf09aba850aef27efa126b3a9fa05cbb357 Mon Sep 17 00:00:00 2001 From: Josh McKinney Date: Thu, 12 Feb 2026 14:47:09 -0800 Subject: [PATCH 1/9] docs: require insta snapshot coverage for UI changes (#10669) Adds an explicit requirement in AGENTS.md that any user-visible UI change includes corresponding insta snapshot coverage and that snapshots are reviewed/accepted in the PR. Tests: N/A (docs only) --- AGENTS.md | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/AGENTS.md b/AGENTS.md index 62f303769e..fc545c5080 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -60,7 +60,14 @@ See `codex-rs/tui/styles.md`. ### Snapshot tests -This repo uses snapshot tests (via `insta`), especially in `codex-rs/tui`, to validate rendered output. When UI or text output changes intentionally, update the snapshots as follows: +This repo uses snapshot tests (via `insta`), especially in `codex-rs/tui`, to validate rendered output. + +**Requirement:** any change that affects user-visible UI (including adding new UI) must include +corresponding `insta` snapshot coverage (add a new snapshot test if one doesn't exist yet, or +update the existing snapshot). Review and accept snapshot updates as part of the PR so UI impact +is easy to review and future diffs stay visual. + +When UI or text output changes intentionally, update the snapshots as follows: - Run tests to generate any updated snapshots: - `cargo test -p codex-tui` From 76256a8ceca6c4f6ff99d7234e2ecebda6c8483e Mon Sep 17 00:00:00 2001 From: Owen Lin Date: Thu, 12 Feb 2026 15:12:57 -0800 Subject: [PATCH 2/9] =?UTF-8?q?fix:=20skip=20review=5Fstart=5Fwith=5Fdetac?= =?UTF-8?q?hed=5Fdelivery=5Freturns=5Fnew=5Fthread=5Fid=20o=E2=80=A6=20(#1?= =?UTF-8?q?1645)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit …n windows --- codex-rs/app-server/tests/suite/v2/review.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/codex-rs/app-server/tests/suite/v2/review.rs b/codex-rs/app-server/tests/suite/v2/review.rs index 7814950a63..641a885807 100644 --- a/codex-rs/app-server/tests/suite/v2/review.rs +++ b/codex-rs/app-server/tests/suite/v2/review.rs @@ -255,6 +255,7 @@ async fn review_start_rejects_empty_base_branch() -> Result<()> { Ok(()) } +#[cfg_attr(target_os = "windows", ignore = "flaky on windows CI")] #[tokio::test] async fn review_start_with_detached_delivery_returns_new_thread_id() -> Result<()> { let review_payload = json!({ From dfd1e199a0d8a54c15261ee7159f9a86b337ac4f Mon Sep 17 00:00:00 2001 From: Celia Chen Date: Thu, 12 Feb 2026 15:30:22 -0800 Subject: [PATCH 3/9] [feat] add seatbelt permission files (#11639) Add seatbelt permission extension abstraction as permission files for seatbelt profiles. This should complement our current sandbox policy --- codex-rs/core/README.md | 24 ++ codex-rs/core/src/lib.rs | 1 + codex-rs/core/src/seatbelt.rs | 125 +++++++++- codex-rs/core/src/seatbelt_base_policy.sbpl | 3 - codex-rs/core/src/seatbelt_permissions.rs | 246 ++++++++++++++++++++ 5 files changed, 393 insertions(+), 6 deletions(-) create mode 100644 codex-rs/core/src/seatbelt_permissions.rs diff --git a/codex-rs/core/README.md b/codex-rs/core/README.md index 9974a591cf..8a66b47b48 100644 --- a/codex-rs/core/README.md +++ b/codex-rs/core/README.md @@ -14,6 +14,30 @@ When using the workspace-write sandbox policy, the Seatbelt profile allows writes under the configured writable roots while keeping `.git` (directory or pointer file), the resolved `gitdir:` target, and `.codex` read-only. +Network access and filesystem read/write roots are controlled by +`SandboxPolicy`. Seatbelt consumes the resolved policy and enforces it. + +Seatbelt also supports macOS permission-profile extensions layered on top of +`SandboxPolicy`: + +- no extension profile provided: + keeps legacy default preferences read access (`user-preference-read`). +- extension profile provided with no `macos_preferences` grant: + does not add preferences access clauses. +- `macos_preferences = "readonly"`: + enables cfprefs read clauses and `user-preference-read`. +- `macos_preferences = "readwrite"`: + includes readonly clauses plus `user-preference-write` and cfprefs shm write + clauses. +- `macos_automation = true`: + enables broad Apple Events send permissions. +- `macos_automation = ["com.apple.Notes", ...]`: + enables Apple Events send only to listed bundle IDs. +- `macos_accessibility = true`: + enables `com.apple.axserver` mach lookup. +- `macos_calendar = true`: + enables `com.apple.CalendarAgent` mach lookup. + ### Linux Expects the binary containing `codex-core` to run the equivalent of `codex sandbox linux` (legacy alias: `codex debug landlock`) when `arg0` is `codex-linux-sandbox`. See the `codex-arg0` crate for details. diff --git a/codex-rs/core/src/lib.rs b/codex-rs/core/src/lib.rs index 764fc4fbba..e3888ecf86 100644 --- a/codex-rs/core/src/lib.rs +++ b/codex-rs/core/src/lib.rs @@ -77,6 +77,7 @@ pub use model_provider_info::create_oss_provider_with_base_url; mod event_mapping; pub mod review_format; pub mod review_prompts; +mod seatbelt_permissions; mod thread_manager; pub mod web_search; pub mod windows_sandbox_read_grants; diff --git a/codex-rs/core/src/seatbelt.rs b/codex-rs/core/src/seatbelt.rs index fc425f2184..29c05e0183 100644 --- a/codex-rs/core/src/seatbelt.rs +++ b/codex-rs/core/src/seatbelt.rs @@ -14,6 +14,9 @@ use tokio::process::Child; use url::Url; use crate::protocol::SandboxPolicy; +use crate::seatbelt_permissions::MacOsPreferencesPermission; +use crate::seatbelt_permissions::MacOsSeatbeltProfileExtensions; +use crate::seatbelt_permissions::build_seatbelt_extensions; use crate::spawn::CODEX_SANDBOX_ENV_VAR; use crate::spawn::SpawnChildRequest; use crate::spawn::StdioPolicy; @@ -179,6 +182,24 @@ pub(crate) fn create_seatbelt_command_args( sandbox_policy_cwd: &Path, enforce_managed_network: bool, network: Option<&NetworkProxy>, +) -> Vec { + create_seatbelt_command_args_with_extensions( + command, + sandbox_policy, + sandbox_policy_cwd, + enforce_managed_network, + network, + None, + ) +} + +pub(crate) fn create_seatbelt_command_args_with_extensions( + command: Vec, + sandbox_policy: &SandboxPolicy, + sandbox_policy_cwd: &Path, + enforce_managed_network: bool, + network: Option<&NetworkProxy>, + extensions: Option<&MacOsSeatbeltProfileExtensions>, ) -> Vec { let (file_write_policy, file_write_dir_params) = { if sandbox_policy.has_full_disk_write_access() { @@ -275,15 +296,33 @@ pub(crate) fn create_seatbelt_command_args( let proxy = proxy_policy_inputs(network); let network_policy = dynamic_network_policy(sandbox_policy, enforce_managed_network, &proxy); - - let full_policy = format!( - "{MACOS_SEATBELT_BASE_POLICY}\n{file_read_policy}\n{file_write_policy}\n{network_policy}" + let seatbelt_extensions = extensions.map_or_else( + || { + // Backward-compatibility default when no extension profile is provided. + build_seatbelt_extensions(&MacOsSeatbeltProfileExtensions { + macos_preferences: MacOsPreferencesPermission::ReadOnly, + ..Default::default() + }) + }, + build_seatbelt_extensions, ); + let full_policy = if seatbelt_extensions.policy.is_empty() { + format!( + "{MACOS_SEATBELT_BASE_POLICY}\n{file_read_policy}\n{file_write_policy}\n{network_policy}" + ) + } else { + format!( + "{MACOS_SEATBELT_BASE_POLICY}\n{file_read_policy}\n{file_write_policy}\n{network_policy}\n{}", + seatbelt_extensions.policy + ) + }; + let dir_params = [ file_read_dir_params, file_write_dir_params, macos_dir_params(), + seatbelt_extensions.dir_params, ] .concat(); @@ -328,10 +367,14 @@ mod tests { use super::MACOS_SEATBELT_BASE_POLICY; use super::ProxyPolicyInputs; use super::create_seatbelt_command_args; + use super::create_seatbelt_command_args_with_extensions; use super::dynamic_network_policy; use super::macos_dir_params; use crate::protocol::SandboxPolicy; use crate::seatbelt::MACOS_PATH_TO_SEATBELT_EXECUTABLE; + use crate::seatbelt_permissions::MacOsAutomationPermission; + use crate::seatbelt_permissions::MacOsPreferencesPermission; + use crate::seatbelt_permissions::MacOsSeatbeltProfileExtensions; use pretty_assertions::assert_eq; use std::fs; use std::path::Path; @@ -395,6 +438,66 @@ mod tests { ); } + #[test] + fn seatbelt_args_include_macos_permission_extensions() { + let cwd = std::env::temp_dir(); + let args = create_seatbelt_command_args_with_extensions( + vec!["echo".to_string(), "ok".to_string()], + &SandboxPolicy::new_read_only_policy(), + cwd.as_path(), + false, + None, + Some(&MacOsSeatbeltProfileExtensions { + macos_preferences: MacOsPreferencesPermission::ReadWrite, + macos_automation: MacOsAutomationPermission::BundleIds(vec![ + "com.apple.Notes".to_string(), + ]), + macos_accessibility: true, + macos_calendar: true, + }), + ); + let policy = &args[1]; + + assert!(policy.contains("(allow user-preference-write)")); + assert!(policy.contains("(appleevent-destination \"com.apple.Notes\")")); + assert!(policy.contains("com.apple.axserver")); + assert!(policy.contains("com.apple.CalendarAgent")); + } + + #[test] + fn seatbelt_args_without_extension_profile_keep_legacy_preferences_read_access() { + let cwd = std::env::temp_dir(); + let args = create_seatbelt_command_args( + vec!["echo".to_string(), "ok".to_string()], + &SandboxPolicy::new_read_only_policy(), + cwd.as_path(), + false, + None, + ); + let policy = &args[1]; + assert!(policy.contains("(allow user-preference-read)")); + assert!(!policy.contains("(allow user-preference-write)")); + } + + #[test] + fn seatbelt_args_omit_macos_extensions_when_profile_is_empty() { + let cwd = std::env::temp_dir(); + let args = create_seatbelt_command_args_with_extensions( + vec!["echo".to_string(), "ok".to_string()], + &SandboxPolicy::new_read_only_policy(), + cwd.as_path(), + false, + None, + Some(&MacOsSeatbeltProfileExtensions::default()), + ); + let policy = &args[1]; + assert!(!policy.contains("appleevent-send")); + assert!(!policy.contains("com.apple.axserver")); + assert!(!policy.contains("com.apple.CalendarAgent")); + assert!(!policy.contains("user-preference-read")); + assert!(!policy.contains("user-preference-write")); + } + #[test] fn create_seatbelt_args_allows_local_binding_when_explicitly_enabled() { let policy = dynamic_network_policy( @@ -564,6 +667,14 @@ mod tests { (allow file-write* (require-all (subpath (param "WRITABLE_ROOT_0")) (require-not (subpath (param "WRITABLE_ROOT_0_RO_0"))) (require-not (subpath (param "WRITABLE_ROOT_0_RO_1"))) ) (subpath (param "WRITABLE_ROOT_1")) (subpath (param "WRITABLE_ROOT_2")) ) + +; macOS permission profile extensions +(allow ipc-posix-shm-read* (ipc-posix-name-prefix "apple.cfprefs.")) +(allow mach-lookup + (global-name "com.apple.cfprefsd.daemon") + (global-name "com.apple.cfprefsd.agent") + (local-name "com.apple.cfprefsd.agent")) +(allow user-preference-read) "#, ); @@ -851,6 +962,14 @@ mod tests { (allow file-write* (require-all (subpath (param "WRITABLE_ROOT_0")) (require-not (subpath (param "WRITABLE_ROOT_0_RO_0"))) (require-not (subpath (param "WRITABLE_ROOT_0_RO_1"))) ) (subpath (param "WRITABLE_ROOT_1")){tempdir_policy_entry} ) + +; macOS permission profile extensions +(allow ipc-posix-shm-read* (ipc-posix-name-prefix "apple.cfprefs.")) +(allow mach-lookup + (global-name "com.apple.cfprefsd.daemon") + (global-name "com.apple.cfprefsd.agent") + (local-name "com.apple.cfprefsd.agent")) +(allow user-preference-read) "#, ); diff --git a/codex-rs/core/src/seatbelt_base_policy.sbpl b/codex-rs/core/src/seatbelt_base_policy.sbpl index 00676a86f4..72b13c96cd 100644 --- a/codex-rs/core/src/seatbelt_base_policy.sbpl +++ b/codex-rs/core/src/seatbelt_base_policy.sbpl @@ -12,9 +12,6 @@ (allow process-fork) (allow signal (target same-sandbox)) -; Allow cf prefs to work. -(allow user-preference-read) - ; process-info (allow process-info* (target same-sandbox)) diff --git a/codex-rs/core/src/seatbelt_permissions.rs b/codex-rs/core/src/seatbelt_permissions.rs new file mode 100644 index 0000000000..29313d7a3c --- /dev/null +++ b/codex-rs/core/src/seatbelt_permissions.rs @@ -0,0 +1,246 @@ +#![cfg(target_os = "macos")] + +use std::collections::BTreeSet; +use std::path::PathBuf; + +#[allow(dead_code)] +#[derive(Debug, Clone, PartialEq, Eq, Default)] +pub enum MacOsPreferencesPermission { + #[default] + None, + ReadOnly, + ReadWrite, +} + +#[allow(dead_code)] +#[derive(Debug, Clone, PartialEq, Eq, Default)] +pub enum MacOsAutomationPermission { + #[default] + None, + All, + BundleIds(Vec), +} + +#[allow(dead_code)] +#[derive(Debug, Clone, PartialEq, Eq, Default)] +pub struct MacOsSeatbeltProfileExtensions { + pub macos_preferences: MacOsPreferencesPermission, + pub macos_automation: MacOsAutomationPermission, + pub macos_accessibility: bool, + pub macos_calendar: bool, +} + +#[derive(Debug, Clone, PartialEq, Eq, Default)] +pub(crate) struct SeatbeltExtensionPolicy { + pub(crate) policy: String, + pub(crate) dir_params: Vec<(String, PathBuf)>, +} + +impl MacOsSeatbeltProfileExtensions { + pub fn normalized(&self) -> Self { + let mut normalized = self.clone(); + if let MacOsAutomationPermission::BundleIds(bundle_ids) = &self.macos_automation { + let bundle_ids = normalize_bundle_ids(bundle_ids); + normalized.macos_automation = if bundle_ids.is_empty() { + MacOsAutomationPermission::None + } else { + MacOsAutomationPermission::BundleIds(bundle_ids) + }; + } + normalized + } +} + +pub(crate) fn build_seatbelt_extensions( + extensions: &MacOsSeatbeltProfileExtensions, +) -> SeatbeltExtensionPolicy { + let extensions = extensions.normalized(); + let mut clauses = Vec::new(); + + match extensions.macos_preferences { + MacOsPreferencesPermission::None => {} + MacOsPreferencesPermission::ReadOnly => { + clauses.push( + "(allow ipc-posix-shm-read* (ipc-posix-name-prefix \"apple.cfprefs.\"))" + .to_string(), + ); + clauses.push( + "(allow mach-lookup\n (global-name \"com.apple.cfprefsd.daemon\")\n (global-name \"com.apple.cfprefsd.agent\")\n (local-name \"com.apple.cfprefsd.agent\"))" + .to_string(), + ); + clauses.push("(allow user-preference-read)".to_string()); + } + MacOsPreferencesPermission::ReadWrite => { + clauses.push( + "(allow ipc-posix-shm-read* (ipc-posix-name-prefix \"apple.cfprefs.\"))" + .to_string(), + ); + clauses.push( + "(allow mach-lookup\n (global-name \"com.apple.cfprefsd.daemon\")\n (global-name \"com.apple.cfprefsd.agent\")\n (local-name \"com.apple.cfprefsd.agent\"))" + .to_string(), + ); + clauses.push("(allow user-preference-read)".to_string()); + clauses.push("(allow user-preference-write)".to_string()); + clauses.push( + "(allow ipc-posix-shm-write-data (ipc-posix-name-prefix \"apple.cfprefs.\"))" + .to_string(), + ); + clauses.push( + "(allow ipc-posix-shm-write-create (ipc-posix-name-prefix \"apple.cfprefs.\"))" + .to_string(), + ); + } + } + + match extensions.macos_automation { + MacOsAutomationPermission::None => {} + MacOsAutomationPermission::All => { + clauses.push( + "(allow mach-lookup\n (global-name \"com.apple.coreservices.launchservicesd\")\n (global-name \"com.apple.coreservices.appleevents\"))" + .to_string(), + ); + clauses.push("(allow appleevent-send)".to_string()); + } + MacOsAutomationPermission::BundleIds(bundle_ids) => { + if !bundle_ids.is_empty() { + clauses.push( + "(allow mach-lookup (global-name \"com.apple.coreservices.appleevents\"))" + .to_string(), + ); + let destinations = bundle_ids + .iter() + .map(|bundle_id| format!(" (appleevent-destination \"{bundle_id}\")")) + .collect::>() + .join("\n"); + clauses.push(format!("(allow appleevent-send\n{destinations}\n)")); + } + } + } + + if extensions.macos_accessibility { + clauses.push("(allow mach-lookup (local-name \"com.apple.axserver\"))".to_string()); + } + + if extensions.macos_calendar { + clauses.push("(allow mach-lookup (global-name \"com.apple.CalendarAgent\"))".to_string()); + } + + if clauses.is_empty() { + SeatbeltExtensionPolicy::default() + } else { + SeatbeltExtensionPolicy { + policy: format!( + "; macOS permission profile extensions\n{}\n", + clauses.join("\n") + ), + dir_params: Vec::new(), + } + } +} + +fn normalize_bundle_ids(bundle_ids: &[String]) -> Vec { + let mut unique = BTreeSet::new(); + for bundle_id in bundle_ids { + let candidate = bundle_id.trim(); + if is_valid_bundle_id(candidate) { + unique.insert(candidate.to_string()); + } + } + unique.into_iter().collect() +} + +fn is_valid_bundle_id(bundle_id: &str) -> bool { + if bundle_id.len() < 3 || !bundle_id.contains('.') { + return false; + } + bundle_id + .chars() + .all(|c| c.is_ascii_alphanumeric() || c == '.' || c == '-' || c == '_') +} + +#[cfg(test)] +mod tests { + use super::MacOsAutomationPermission; + use super::MacOsPreferencesPermission; + use super::MacOsSeatbeltProfileExtensions; + use super::build_seatbelt_extensions; + use pretty_assertions::assert_eq; + + #[test] + fn preferences_read_only_emits_read_clauses_only() { + let policy = build_seatbelt_extensions(&MacOsSeatbeltProfileExtensions { + macos_preferences: MacOsPreferencesPermission::ReadOnly, + ..Default::default() + }); + assert!(policy.policy.contains("(allow user-preference-read)")); + assert!(!policy.policy.contains("(allow user-preference-write)")); + } + + #[test] + fn preferences_read_write_emits_write_clauses() { + let policy = build_seatbelt_extensions(&MacOsSeatbeltProfileExtensions { + macos_preferences: MacOsPreferencesPermission::ReadWrite, + ..Default::default() + }); + assert!(policy.policy.contains("(allow user-preference-read)")); + assert!(policy.policy.contains("(allow user-preference-write)")); + assert!(policy.policy.contains( + "(allow ipc-posix-shm-write-create (ipc-posix-name-prefix \"apple.cfprefs.\"))" + )); + } + + #[test] + fn automation_all_emits_unscoped_appleevents() { + let policy = build_seatbelt_extensions(&MacOsSeatbeltProfileExtensions { + macos_automation: MacOsAutomationPermission::All, + ..Default::default() + }); + assert!(policy.policy.contains("(allow appleevent-send)")); + assert!( + policy + .policy + .contains("com.apple.coreservices.launchservicesd") + ); + } + + #[test] + fn automation_bundle_ids_are_normalized_and_scoped() { + let policy = build_seatbelt_extensions(&MacOsSeatbeltProfileExtensions { + macos_automation: MacOsAutomationPermission::BundleIds(vec![ + " com.apple.Notes ".to_string(), + "com.apple.Calendar".to_string(), + "bad bundle".to_string(), + "com.apple.Notes".to_string(), + ]), + ..Default::default() + }); + assert!( + policy + .policy + .contains("(appleevent-destination \"com.apple.Calendar\")") + ); + assert!( + policy + .policy + .contains("(appleevent-destination \"com.apple.Notes\")") + ); + assert!(!policy.policy.contains("bad bundle")); + } + + #[test] + fn accessibility_and_calendar_emit_mach_lookups() { + let policy = build_seatbelt_extensions(&MacOsSeatbeltProfileExtensions { + macos_accessibility: true, + macos_calendar: true, + ..Default::default() + }); + assert!(policy.policy.contains("com.apple.axserver")); + assert!(policy.policy.contains("com.apple.CalendarAgent")); + } + + #[test] + fn empty_extensions_emit_empty_policy() { + let policy = build_seatbelt_extensions(&MacOsSeatbeltProfileExtensions::default()); + assert_eq!(policy.policy, ""); + } +} From a7ce2a1c3128e8e3a59671480840b3eae277603d Mon Sep 17 00:00:00 2001 From: Wendy Jiao Date: Thu, 12 Feb 2026 15:32:41 -0800 Subject: [PATCH 4/9] Remove absolute path in rollout_summary (#11622) --- codex-rs/core/templates/memories/stage_one_system.md | 1 - 1 file changed, 1 deletion(-) diff --git a/codex-rs/core/templates/memories/stage_one_system.md b/codex-rs/core/templates/memories/stage_one_system.md index b4f16a07d7..38031e8d2f 100644 --- a/codex-rs/core/templates/memories/stage_one_system.md +++ b/codex-rs/core/templates/memories/stage_one_system.md @@ -153,7 +153,6 @@ distilled into MEMORY.md and memory_summary.md. There is no strict size limit, and you should feel free to list a lot of points here as long as they are helpful. Instructional notes in angle brackets are guidance only; do not include them verbatim in the rollout summary. -Use absolute paths for any file paths and commands. You should refer to the cwd of the rollout. Template (items are flexible; include only what is useful): From 0dcfc59171410f8c1baff570eb1430e25271a904 Mon Sep 17 00:00:00 2001 From: Curtis 'Fjord' Hawthorne Date: Thu, 12 Feb 2026 15:41:05 -0800 Subject: [PATCH 5/9] Add js_repl_tools_only model and routing restrictions (#10671) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit # External (non-OpenAI) Pull Request Requirements Before opening this Pull Request, please read the dedicated "Contributing" markdown file or your PR may be closed: https://github.com/openai/codex/blob/main/docs/contributing.md If your PR conforms to our contribution guidelines, replace this text with a detailed and high quality description of your changes. Include a link to a bug report or enhancement request. #### [git stack](https://github.com/magus/git-stack-cli) - ✅ `1` https://github.com/openai/codex/pull/10674 - ✅ `2` https://github.com/openai/codex/pull/10672 - 👉 `3` https://github.com/openai/codex/pull/10671 - ⏳ `4` https://github.com/openai/codex/pull/10673 - ⏳ `5` https://github.com/openai/codex/pull/10670 --- codex-rs/core/config.schema.json | 6 ++ codex-rs/core/src/codex.rs | 2 + codex-rs/core/src/features.rs | 12 +++ codex-rs/core/src/project_doc.rs | 21 ++++ codex-rs/core/src/tools/js_repl/mod.rs | 8 +- codex-rs/core/src/tools/parallel.rs | 8 +- codex-rs/core/src/tools/router.rs | 137 +++++++++++++++++++++++++ codex-rs/core/src/tools/spec.rs | 105 ++++++++++++++++++- docs/js_repl.md | 10 ++ 9 files changed, 306 insertions(+), 3 deletions(-) diff --git a/codex-rs/core/config.schema.json b/codex-rs/core/config.schema.json index 4c571a6c2e..1bd7c1a938 100644 --- a/codex-rs/core/config.schema.json +++ b/codex-rs/core/config.schema.json @@ -224,6 +224,9 @@ "js_repl": { "type": "boolean" }, + "js_repl_tools_only": { + "type": "boolean" + }, "memory_tool": { "type": "boolean" }, @@ -1308,6 +1311,9 @@ "js_repl": { "type": "boolean" }, + "js_repl_tools_only": { + "type": "boolean" + }, "memory_tool": { "type": "boolean" }, diff --git a/codex-rs/core/src/codex.rs b/codex-rs/core/src/codex.rs index 75a2551f79..4405635ce3 100644 --- a/codex-rs/core/src/codex.rs +++ b/codex-rs/core/src/codex.rs @@ -5515,6 +5515,7 @@ mod tests { use crate::tools::handlers::ShellHandler; use crate::tools::handlers::UnifiedExecHandler; use crate::tools::registry::ToolHandler; + use crate::tools::router::ToolCallSource; use crate::turn_diff_tracker::TurnDiffTracker; use codex_app_server_protocol::AppInfo; use codex_otel::TelemetryAuthMode; @@ -7452,6 +7453,7 @@ mod tests { Arc::clone(&turn_context), tracker, call, + ToolCallSource::Direct, ) .await .expect_err("expected fatal error"); diff --git a/codex-rs/core/src/features.rs b/codex-rs/core/src/features.rs index 4a64d81f89..9df518b816 100644 --- a/codex-rs/core/src/features.rs +++ b/codex-rs/core/src/features.rs @@ -80,6 +80,8 @@ pub enum Feature { // Experimental /// Enable JavaScript REPL tools backed by a persistent Node kernel. JsRepl, + /// Only expose js_repl tools directly to the model. + JsReplToolsOnly, /// Use the single unified PTY-backed exec tool. UnifiedExec, /// Include the freeform apply_patch tool. @@ -322,6 +324,10 @@ impl Features { } overrides.apply(&mut features); + if features.enabled(Feature::JsReplToolsOnly) && !features.enabled(Feature::JsRepl) { + tracing::warn!("js_repl_tools_only requires js_repl; disabling js_repl_tools_only"); + features.disable(Feature::JsReplToolsOnly); + } features } @@ -430,6 +436,12 @@ pub const FEATURES: &[FeatureSpec] = &[ stage: Stage::UnderDevelopment, default_enabled: false, }, + FeatureSpec { + id: Feature::JsReplToolsOnly, + key: "js_repl_tools_only", + stage: Stage::UnderDevelopment, + default_enabled: false, + }, FeatureSpec { id: Feature::WebSearchRequest, key: "web_search_request", diff --git a/codex-rs/core/src/project_doc.rs b/codex-rs/core/src/project_doc.rs index a530a83379..3d2b55ab5b 100644 --- a/codex-rs/core/src/project_doc.rs +++ b/codex-rs/core/src/project_doc.rs @@ -48,6 +48,12 @@ fn render_js_repl_instructions(config: &Config) -> Option { section.push_str("- Top-level bindings persist across cells. If you hit `SyntaxError: Identifier 'x' has already been declared`, reuse the binding, pick a new name, wrap in `{ ... }` for block scope, or reset the kernel with `js_repl_reset`.\n"); section.push_str("- Top-level static import declarations (for example `import x from \"pkg\"`) are currently unsupported in `js_repl`; use dynamic imports with `await import(\"pkg\")` instead.\n"); + if config.features.enabled(Feature::JsReplToolsOnly) { + section.push_str("- Do not call tools directly; use `js_repl` + `codex.tool(...)` for all tool calls, including shell commands.\n"); + section + .push_str("- MCP tools (if any) can also be called by name via `codex.tool(...)`.\n"); + } + section.push_str("- Avoid direct access to `process.stdout` / `process.stderr` / `process.stdin`; it can corrupt the JSON line protocol. Use `console.log` and `codex.tool(...)`."); Some(section) @@ -413,6 +419,21 @@ mod tests { assert_eq!(res, expected); } + #[tokio::test] + async fn js_repl_tools_only_instructions_are_feature_gated() { + let tmp = tempfile::tempdir().expect("tempdir"); + let mut cfg = make_config(&tmp, 4096, None).await; + cfg.features + .enable(Feature::JsRepl) + .enable(Feature::JsReplToolsOnly); + + let res = get_user_instructions(&cfg, None) + .await + .expect("js_repl instructions expected"); + let expected = "## JavaScript REPL (Node)\n- Use `js_repl` for Node-backed JavaScript with top-level await in a persistent kernel. `codex.state` persists for the session (best effort) and is cleared by `js_repl_reset`.\n- `js_repl` is a freeform/custom tool. Direct `js_repl` calls must send raw JavaScript tool input (optionally with first-line `// codex-js-repl: timeout_ms=15000`). Do not wrap code in JSON (for example `{\"code\":\"...\"}`), quotes, or markdown code fences.\n- Helpers: `codex.state`, `codex.tmpDir`, and `codex.tool(name, args?)`.\n- `codex.tool` executes a normal tool call and resolves to the raw tool output object. Use it for shell and non-shell tools alike.\n- To share generated images with the model, write a file under `codex.tmpDir`, call `await codex.tool(\"view_image\", { path: \"/absolute/path\" })`, then delete the file.\n- Top-level bindings persist across cells. If you hit `SyntaxError: Identifier 'x' has already been declared`, reuse the binding, pick a new name, wrap in `{ ... }` for block scope, or reset the kernel with `js_repl_reset`.\n- Top-level static import declarations (for example `import x from \"pkg\"`) are currently unsupported in `js_repl`; use dynamic imports with `await import(\"pkg\")` instead.\n- Do not call tools directly; use `js_repl` + `codex.tool(...)` for all tool calls, including shell commands.\n- MCP tools (if any) can also be called by name via `codex.tool(...)`.\n- Avoid direct access to `process.stdout` / `process.stderr` / `process.stdin`; it can corrupt the JSON line protocol. Use `console.log` and `codex.tool(...)`."; + assert_eq!(res, expected); + } + /// When both system instructions *and* a project doc are present the two /// should be concatenated with the separator. #[tokio::test] diff --git a/codex-rs/core/src/tools/js_repl/mod.rs b/codex-rs/core/src/tools/js_repl/mod.rs index 4285c29889..8b362ab8f3 100644 --- a/codex-rs/core/src/tools/js_repl/mod.rs +++ b/codex-rs/core/src/tools/js_repl/mod.rs @@ -680,7 +680,13 @@ impl JsReplManager { }; match router - .dispatch_tool_call(exec.session, exec.turn, exec.tracker, call) + .dispatch_tool_call( + exec.session, + exec.turn, + exec.tracker, + call, + crate::tools::router::ToolCallSource::JsRepl, + ) .await { Ok(response) => match serde_json::to_value(response) { diff --git a/codex-rs/core/src/tools/parallel.rs b/codex-rs/core/src/tools/parallel.rs index ca08048bd8..04d505c584 100644 --- a/codex-rs/core/src/tools/parallel.rs +++ b/codex-rs/core/src/tools/parallel.rs @@ -85,7 +85,13 @@ impl ToolCallRuntime { }; router - .dispatch_tool_call(session, turn, tracker, call.clone()) + .dispatch_tool_call( + session, + turn, + tracker, + call.clone(), + crate::tools::router::ToolCallSource::Direct, + ) .instrument(dispatch_span.clone()) .await } => res, diff --git a/codex-rs/core/src/tools/router.rs b/codex-rs/core/src/tools/router.rs index 1eb6190bcb..1cc8b91778 100644 --- a/codex-rs/core/src/tools/router.rs +++ b/codex-rs/core/src/tools/router.rs @@ -28,6 +28,12 @@ pub struct ToolCall { pub payload: ToolPayload, } +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub enum ToolCallSource { + Direct, + JsRepl, +} + pub struct ToolRouter { registry: ToolRegistry, specs: Vec, @@ -138,6 +144,7 @@ impl ToolRouter { turn: Arc, tracker: SharedTurnDiffTracker, call: ToolCall, + source: ToolCallSource, ) -> Result { let ToolCall { tool_name, @@ -147,6 +154,21 @@ impl ToolRouter { let payload_outputs_custom = matches!(payload, ToolPayload::Custom { .. }); let failure_call_id = call_id.clone(); + if source == ToolCallSource::Direct + && turn.tools_config.js_repl_tools_only + && !matches!(tool_name.as_str(), "js_repl" | "js_repl_reset") + { + let err = FunctionCallError::RespondToModel( + "direct tool calls are disabled; use js_repl and codex.tool(...) instead" + .to_string(), + ); + return Ok(Self::failure_response( + failure_call_id, + payload_outputs_custom, + err, + )); + } + let invocation = ToolInvocation { session, turn, @@ -189,3 +211,118 @@ impl ToolRouter { } } } +#[cfg(test)] +mod tests { + use std::sync::Arc; + + use crate::codex::make_session_and_context; + use crate::tools::context::ToolPayload; + use crate::turn_diff_tracker::TurnDiffTracker; + use codex_protocol::models::ResponseInputItem; + + use super::ToolCall; + use super::ToolCallSource; + use super::ToolRouter; + + #[tokio::test] + async fn js_repl_tools_only_blocks_direct_tool_calls() -> anyhow::Result<()> { + let (session, mut turn) = make_session_and_context().await; + turn.tools_config.js_repl_tools_only = true; + + let session = Arc::new(session); + let turn = Arc::new(turn); + let mcp_tools = session + .services + .mcp_connection_manager + .read() + .await + .list_all_tools() + .await; + let router = ToolRouter::from_config( + &turn.tools_config, + Some( + mcp_tools + .into_iter() + .map(|(name, tool)| (name, tool.tool)) + .collect(), + ), + turn.dynamic_tools.as_slice(), + ); + + let call = ToolCall { + tool_name: "shell".to_string(), + call_id: "call-1".to_string(), + payload: ToolPayload::Function { + arguments: "{}".to_string(), + }, + }; + let tracker = Arc::new(tokio::sync::Mutex::new(TurnDiffTracker::new())); + let response = router + .dispatch_tool_call(session, turn, tracker, call, ToolCallSource::Direct) + .await?; + + match response { + ResponseInputItem::FunctionCallOutput { output, .. } => { + let content = output.text_content().unwrap_or_default(); + assert!( + content.contains("direct tool calls are disabled"), + "unexpected tool call message: {content}", + ); + } + other => panic!("expected function call output, got {other:?}"), + } + + Ok(()) + } + + #[tokio::test] + async fn js_repl_tools_only_allows_js_repl_source_calls() -> anyhow::Result<()> { + let (session, mut turn) = make_session_and_context().await; + turn.tools_config.js_repl_tools_only = true; + + let session = Arc::new(session); + let turn = Arc::new(turn); + let mcp_tools = session + .services + .mcp_connection_manager + .read() + .await + .list_all_tools() + .await; + let router = ToolRouter::from_config( + &turn.tools_config, + Some( + mcp_tools + .into_iter() + .map(|(name, tool)| (name, tool.tool)) + .collect(), + ), + turn.dynamic_tools.as_slice(), + ); + + let call = ToolCall { + tool_name: "shell".to_string(), + call_id: "call-2".to_string(), + payload: ToolPayload::Function { + arguments: "{}".to_string(), + }, + }; + let tracker = Arc::new(tokio::sync::Mutex::new(TurnDiffTracker::new())); + let response = router + .dispatch_tool_call(session, turn, tracker, call, ToolCallSource::JsRepl) + .await?; + + match response { + ResponseInputItem::FunctionCallOutput { output, .. } => { + let content = output.text_content().unwrap_or_default(); + assert!( + !content.contains("direct tool calls are disabled"), + "js_repl source should bypass direct-call policy gate" + ); + } + other => panic!("expected function call output, got {other:?}"), + } + + Ok(()) + } +} diff --git a/codex-rs/core/src/tools/spec.rs b/codex-rs/core/src/tools/spec.rs index b8618e0c07..82e34298c1 100644 --- a/codex-rs/core/src/tools/spec.rs +++ b/codex-rs/core/src/tools/spec.rs @@ -34,6 +34,7 @@ pub(crate) struct ToolsConfig { pub web_search_mode: Option, pub search_tool: bool, pub js_repl_enabled: bool, + pub js_repl_tools_only: bool, pub collab_tools: bool, pub collaboration_modes_tools: bool, pub request_rule_enabled: bool, @@ -55,6 +56,8 @@ impl ToolsConfig { } = params; let include_apply_patch_tool = features.enabled(Feature::ApplyPatchFreeform); let include_js_repl = features.enabled(Feature::JsRepl); + let include_js_repl_tools_only = + include_js_repl && features.enabled(Feature::JsReplToolsOnly); let include_collab_tools = features.enabled(Feature::Collab); let include_collaboration_modes_tools = features.enabled(Feature::CollaborationModes); let request_rule_enabled = features.enabled(Feature::RequestRule); @@ -91,6 +94,7 @@ impl ToolsConfig { web_search_mode: *web_search_mode, search_tool: include_search_tool, js_repl_enabled: include_js_repl, + js_repl_tools_only: include_js_repl_tools_only, collab_tools: include_collab_tools, collaboration_modes_tools: include_collaboration_modes_tools, request_rule_enabled, @@ -99,8 +103,15 @@ impl ToolsConfig { } } -pub(crate) fn filter_tools_for_model(tools: Vec, _config: &ToolsConfig) -> Vec { +pub(crate) fn filter_tools_for_model(tools: Vec, config: &ToolsConfig) -> Vec { + if !config.js_repl_tools_only { + return tools; + } + tools + .into_iter() + .filter(|spec| matches!(spec.name(), "js_repl" | "js_repl_reset")) + .collect() } /// Generic JSON‑Schema subset needed for our tool definitions @@ -1685,6 +1696,27 @@ mod tests { } } + fn assert_contains_tool_specs(tools: &[ToolSpec], expected_subset: &[&str]) { + use std::collections::HashSet; + let mut names = HashSet::new(); + let mut duplicates = Vec::new(); + for name in tools.iter().map(tool_name) { + if !names.insert(name) { + duplicates.push(name); + } + } + assert!( + duplicates.is_empty(), + "duplicate tool entries detected: {duplicates:?}" + ); + for expected in expected_subset { + assert!( + names.contains(expected), + "expected tool {expected} to be present; had: {names:?}" + ); + } + } + fn shell_tool_name(config: &ToolsConfig) -> Option<&'static str> { match config.shell_type { ConfigShellToolType::Default => Some("shell"), @@ -1910,6 +1942,77 @@ mod tests { assert_contains_tool_names(&tools, &["js_repl", "js_repl_reset"]); } + #[test] + fn js_repl_tools_only_filters_model_tools() { + let config = test_config(); + let model_info = + ModelsManager::construct_model_info_offline_for_tests("gpt-5-codex", &config); + let mut features = Features::with_defaults(); + features.enable(Feature::JsRepl); + features.enable(Feature::JsReplToolsOnly); + + let tools_config = ToolsConfig::new(&ToolsConfigParams { + model_info: &model_info, + features: &features, + web_search_mode: Some(WebSearchMode::Cached), + }); + let (tools, _) = build_specs(&tools_config, None, &[]).build(); + let filtered = filter_tools_for_model( + tools.iter().map(|tool| tool.spec.clone()).collect(), + &tools_config, + ); + assert_contains_tool_specs(&filtered, &["js_repl", "js_repl_reset"]); + assert!( + !filtered.iter().any(|tool| tool_name(tool) == "shell"), + "expected non-js_repl tools to be hidden when js_repl_tools_only is enabled" + ); + } + + #[test] + fn js_repl_tools_only_hides_dynamic_tools_from_model_tools() { + let config = test_config(); + let model_info = + ModelsManager::construct_model_info_offline_for_tests("gpt-5-codex", &config); + let mut features = Features::with_defaults(); + features.enable(Feature::JsRepl); + features.enable(Feature::JsReplToolsOnly); + + let tools_config = ToolsConfig::new(&ToolsConfigParams { + model_info: &model_info, + features: &features, + web_search_mode: Some(WebSearchMode::Cached), + }); + let dynamic_tools = vec![DynamicToolSpec { + name: "dynamic_echo".to_string(), + description: "echo dynamic payload".to_string(), + input_schema: serde_json::json!({ + "type": "object", + "properties": { + "text": {"type": "string"} + }, + "required": ["text"], + "additionalProperties": false + }), + }]; + let (tools, _) = build_specs(&tools_config, None, &dynamic_tools).build(); + assert!( + tools.iter().any(|tool| tool.spec.name() == "dynamic_echo"), + "expected dynamic tool in full router specs" + ); + + let filtered = filter_tools_for_model( + tools.iter().map(|tool| tool.spec.clone()).collect(), + &tools_config, + ); + assert!( + !filtered + .iter() + .any(|tool| tool_name(tool) == "dynamic_echo"), + "expected dynamic tools to be hidden from direct model tools in js_repl_tools_only mode" + ); + assert_contains_tool_specs(&filtered, &["js_repl", "js_repl_reset"]); + } + fn assert_model_tools( model_slug: &str, features: &Features, diff --git a/docs/js_repl.md b/docs/js_repl.md index 2c550b4581..1b19740748 100644 --- a/docs/js_repl.md +++ b/docs/js_repl.md @@ -11,6 +11,16 @@ js_repl = true ``` +`js_repl_tools_only` can be enabled to force direct model tool calls through `js_repl`: + +```toml +[features] +js_repl = true +js_repl_tools_only = true +``` + +When enabled, direct model tool calls are restricted to `js_repl` and `js_repl_reset`; other tools remain available via `await codex.tool(...)` inside js_repl. + ## Node runtime `js_repl` requires a Node version that meets or exceeds `codex-rs/node-version.txt`. From aef4af107904aadf13dd3b68d6163ca07f3f7087 Mon Sep 17 00:00:00 2001 From: Michael Bolin Date: Thu, 12 Feb 2026 15:56:43 -0800 Subject: [PATCH 6/9] app-server tests: disable shell_snapshot for review suite (#11657) ## Why `suite::v2::review::review_start_with_detached_delivery_returns_new_thread_id` was failing on Windows CI due to an unrelated process crash during shell snapshot initialization (`tokio-runtime-worker` stack overflow). This review test suite validates review API behavior and should not depend on shell snapshot behavior. Keeping shell snapshot enabled in this fixture made the test flaky for reasons outside the scenario under test. ## What Changed - Updated the review suite test config in `codex-rs/app-server/tests/suite/v2/review.rs` to set: - `shell_snapshot = false` This keeps the review tests focused on review behavior by disabling shell snapshot initialization in this fixture. ## Verification - `cargo test -p codex-app-server` - Confirmed the previously failing Windows CI job for this test now passes on this PR. --- codex-rs/app-server/tests/suite/v2/review.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/codex-rs/app-server/tests/suite/v2/review.rs b/codex-rs/app-server/tests/suite/v2/review.rs index 641a885807..05397d485d 100644 --- a/codex-rs/app-server/tests/suite/v2/review.rs +++ b/codex-rs/app-server/tests/suite/v2/review.rs @@ -438,6 +438,7 @@ model_provider = "mock_provider" [features] remote_models = false +shell_snapshot = false [model_providers.mock_provider] name = "Mock provider" From 2825ac85a809c9cae31c69d9e29640e04c640136 Mon Sep 17 00:00:00 2001 From: Michael Bolin Date: Thu, 12 Feb 2026 16:12:44 -0800 Subject: [PATCH 7/9] app-server: stabilize detached review start on Windows (#11646) ## Why `review_start_with_detached_delivery_returns_new_thread_id` has been failing on Windows CI. The failure mode is a process crash (`tokio-runtime-worker` stack overflow) during detached review setup, which causes EOF in the test harness. This test is intended to validate detached review thread identity, not shell snapshot behavior. We also still want detached review to avoid unnecessary rollout-path rediscovery when the parent thread is already loaded. ## What Changed - Updated detached review startup in `codex-rs/app-server/src/codex_message_processor.rs`: - `start_detached_review` now receives the loaded parent thread. - It prefers `parent_thread.rollout_path()`. - It falls back to `find_thread_path_by_id_str(...)` only if the in-memory path is unavailable. - Hardened the review test fixture in `codex-rs/app-server/tests/suite/v2/review.rs` by setting `shell_snapshot = false` in test config, so this test no longer depends on unrelated Windows PowerShell snapshot initialization. ## Verification - `cargo test -p codex-app-server` - Verified `suite::v2::review::review_start_with_detached_delivery_returns_new_thread_id` passes locally. ## Notes - Related context: rollout-path lookup behavior changed in #10532. --- codex-rs/app-server/src/codex_message_processor.rs | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/codex-rs/app-server/src/codex_message_processor.rs b/codex-rs/app-server/src/codex_message_processor.rs index aaffa266f0..f1e4b83d2c 100644 --- a/codex-rs/app-server/src/codex_message_processor.rs +++ b/codex-rs/app-server/src/codex_message_processor.rs @@ -5152,10 +5152,13 @@ impl CodexMessageProcessor { &mut self, request_id: &ConnectionRequestId, parent_thread_id: ThreadId, + parent_thread: Arc, review_request: ReviewRequest, display_text: &str, ) -> std::result::Result<(), JSONRPCErrorError> { - let rollout_path = + let rollout_path = if let Some(path) = parent_thread.rollout_path() { + path + } else { find_thread_path_by_id_str(&self.config.codex_home, &parent_thread_id.to_string()) .await .map_err(|err| JSONRPCErrorError { @@ -5167,7 +5170,8 @@ impl CodexMessageProcessor { code: INVALID_REQUEST_ERROR_CODE, message: format!("no rollout found for thread id {parent_thread_id}"), data: None, - })?; + })? + }; let mut config = self.config.as_ref().clone(); if let Some(review_model) = &config.review_model { @@ -5290,6 +5294,7 @@ impl CodexMessageProcessor { .start_detached_review( &request_id, parent_thread_id, + parent_thread, review_request, display_text.as_str(), ) From 8d97b5c2466e9635373e8236a3725cbf7cd7aacf Mon Sep 17 00:00:00 2001 From: Owen Lin Date: Thu, 12 Feb 2026 16:14:55 -0800 Subject: [PATCH 8/9] fix(app-server): surface more helpful errors for json-rpc (#11638) Propagate client JSON-RPC errors for app-server request callbacks. Previously a number of possible errors were collapsed to `channel closed`. Now we should be able to see the underlying client error. ### Summary This change stops masking client JSON-RPC error responses as generic callback cancellation in app-server server->client request flows. Previously, when the client responded with a JSON-RPC error, we removed the callback entry but did not send anything to the waiting oneshot receiver. Waiters then observed channel closure (for example, auth refresh request canceled: channel closed), which hid the actual client error. Now, client JSON-RPC errors are forwarded through the callback channel and handled explicitly by request consumers. ### User-visible behavior - External auth refresh now surfaces real client JSON-RPC errors when provided. - True transport/callback-drop cases still report canceled/channel-closed semantics. ### Example: client JSON-RPC error is now propagated (not masked as "canceled") When app-server asks the client to refresh ChatGPT auth tokens, it sends a server->client JSON-RPC request like: ```json { "id": 42, "method": "account/chatgptAuthTokens/refresh", "params": { "reason": "unauthorized", "previousAccountId": "org-abc" } } ``` If the client cannot refresh and responds with a JSON-RPC error: ``` { "id": 42, "error": { "code": -32000, "message": "refresh failed", "data": null } } ``` app-server now forwards that error through the callback path and surfaces: `auth refresh request failed: code=-32000 message=refresh failed` Previously, this same case could be reported as: `auth refresh request canceled: channel closed` --- .../app-server/src/bespoke_event_handling.rs | 62 ++++++++++++++++--- codex-rs/app-server/src/dynamic_tools.rs | 25 +++++++- codex-rs/app-server/src/message_processor.rs | 17 ++++- codex-rs/app-server/src/outgoing_message.rs | 55 +++++++++++++--- 4 files changed, 137 insertions(+), 22 deletions(-) diff --git a/codex-rs/app-server/src/bespoke_event_handling.rs b/codex-rs/app-server/src/bespoke_event_handling.rs index 79170e64bc..c1f36e1ef3 100644 --- a/codex-rs/app-server/src/bespoke_event_handling.rs +++ b/codex-rs/app-server/src/bespoke_event_handling.rs @@ -4,6 +4,7 @@ use crate::codex_message_processor::read_summary_from_rollout; use crate::codex_message_processor::summary_to_thread; use crate::error_code::INTERNAL_ERROR_CODE; use crate::error_code::INVALID_REQUEST_ERROR_CODE; +use crate::outgoing_message::ClientRequestResult; use crate::outgoing_message::ThreadScopedOutgoingMessageSender; use crate::thread_state::ThreadState; use crate::thread_state::TurnSummary; @@ -1408,12 +1409,25 @@ async fn handle_error( async fn on_patch_approval_response( call_id: String, - receiver: oneshot::Receiver, + receiver: oneshot::Receiver, codex: Arc, ) { let response = receiver.await; let value = match response { - Ok(value) => value, + Ok(Ok(value)) => value, + Ok(Err(err)) => { + error!("request failed with client error: {err:?}"); + if let Err(submit_err) = codex + .submit(Op::PatchApproval { + id: call_id.clone(), + decision: ReviewDecision::Denied, + }) + .await + { + error!("failed to submit denied PatchApproval after request failure: {submit_err}"); + } + return; + } Err(err) => { error!("request failed: {err:?}"); if let Err(submit_err) = codex @@ -1451,12 +1465,16 @@ async fn on_patch_approval_response( async fn on_exec_approval_response( call_id: String, turn_id: String, - receiver: oneshot::Receiver, + receiver: oneshot::Receiver, conversation: Arc, ) { let response = receiver.await; let value = match response { - Ok(value) => value, + Ok(Ok(value)) => value, + Ok(Err(err)) => { + error!("request failed with client error: {err:?}"); + return; + } Err(err) => { error!("request failed: {err:?}"); return; @@ -1488,12 +1506,28 @@ async fn on_exec_approval_response( async fn on_request_user_input_response( event_turn_id: String, - receiver: oneshot::Receiver, + receiver: oneshot::Receiver, conversation: Arc, ) { let response = receiver.await; let value = match response { - Ok(value) => value, + Ok(Ok(value)) => value, + Ok(Err(err)) => { + error!("request failed with client error: {err:?}"); + let empty = CoreRequestUserInputResponse { + answers: HashMap::new(), + }; + if let Err(err) = conversation + .submit(Op::UserInputAnswer { + id: event_turn_id, + response: empty, + }) + .await + { + error!("failed to submit UserInputAnswer: {err}"); + } + return; + } Err(err) => { error!("request failed: {err:?}"); let empty = CoreRequestUserInputResponse { @@ -1628,14 +1662,14 @@ async fn on_file_change_request_approval_response( conversation_id: ThreadId, item_id: String, changes: Vec, - receiver: oneshot::Receiver, + receiver: oneshot::Receiver, codex: Arc, outgoing: ThreadScopedOutgoingMessageSender, thread_state: Arc>, ) { let response = receiver.await; let (decision, completion_status) = match response { - Ok(value) => { + Ok(Ok(value)) => { let response = serde_json::from_value::(value) .unwrap_or_else(|err| { error!("failed to deserialize FileChangeRequestApprovalResponse: {err}"); @@ -1650,6 +1684,10 @@ async fn on_file_change_request_approval_response( // Only short-circuit on declines/cancels/failures. (decision, completion_status) } + Ok(Err(err)) => { + error!("request failed with client error: {err:?}"); + (ReviewDecision::Denied, Some(PatchApplyStatus::Failed)) + } Err(err) => { error!("request failed: {err:?}"); (ReviewDecision::Denied, Some(PatchApplyStatus::Failed)) @@ -1688,13 +1726,13 @@ async fn on_command_execution_request_approval_response( command: String, cwd: PathBuf, command_actions: Vec, - receiver: oneshot::Receiver, + receiver: oneshot::Receiver, conversation: Arc, outgoing: ThreadScopedOutgoingMessageSender, ) { let response = receiver.await; let (decision, completion_status) = match response { - Ok(value) => { + Ok(Ok(value)) => { let response = serde_json::from_value::(value) .unwrap_or_else(|err| { error!("failed to deserialize CommandExecutionRequestApprovalResponse: {err}"); @@ -1729,6 +1767,10 @@ async fn on_command_execution_request_approval_response( }; (decision, completion_status) } + Ok(Err(err)) => { + error!("request failed with client error: {err:?}"); + (ReviewDecision::Denied, Some(CommandExecutionStatus::Failed)) + } Err(err) => { error!("request failed: {err:?}"); (ReviewDecision::Denied, Some(CommandExecutionStatus::Failed)) diff --git a/codex-rs/app-server/src/dynamic_tools.rs b/codex-rs/app-server/src/dynamic_tools.rs index ed284452b4..31374d80b6 100644 --- a/codex-rs/app-server/src/dynamic_tools.rs +++ b/codex-rs/app-server/src/dynamic_tools.rs @@ -7,14 +7,35 @@ use std::sync::Arc; use tokio::sync::oneshot; use tracing::error; +use crate::outgoing_message::ClientRequestResult; + pub(crate) async fn on_call_response( call_id: String, - receiver: oneshot::Receiver, + receiver: oneshot::Receiver, conversation: Arc, ) { let response = receiver.await; let value = match response { - Ok(value) => value, + Ok(Ok(value)) => value, + Ok(Err(err)) => { + error!("request failed with client error: {err:?}"); + let fallback = CoreDynamicToolResponse { + content_items: vec![CoreDynamicToolCallOutputContentItem::InputText { + text: "dynamic tool request failed".to_string(), + }], + success: false, + }; + if let Err(err) = conversation + .submit(Op::DynamicToolResponse { + id: call_id.clone(), + response: fallback, + }) + .await + { + error!("failed to submit DynamicToolResponse: {err}"); + } + return; + } Err(err) => { error!("request failed: {err:?}"); let fallback = CoreDynamicToolResponse { diff --git a/codex-rs/app-server/src/message_processor.rs b/codex-rs/app-server/src/message_processor.rs index f4b949ed28..cb645ff3f8 100644 --- a/codex-rs/app-server/src/message_processor.rs +++ b/codex-rs/app-server/src/message_processor.rs @@ -86,9 +86,20 @@ impl ExternalAuthRefresher for ExternalAuthRefreshBridge { .await; let result = match timeout(EXTERNAL_AUTH_REFRESH_TIMEOUT, rx).await { - Ok(result) => result.map_err(|err| { - std::io::Error::other(format!("auth refresh request canceled: {err}")) - })?, + Ok(result) => { + // Two failure scenarios: + // 1) `oneshot::Receiver` failed (sender dropped) => request canceled/channel closed. + // 2) client answered with JSON-RPC error payload => propagate code/message. + let result = result.map_err(|err| { + std::io::Error::other(format!("auth refresh request canceled: {err}")) + })?; + result.map_err(|err| { + std::io::Error::other(format!( + "auth refresh request failed: code={} message={}", + err.code, err.message + )) + })? + } Err(_) => { let _canceled = self.outgoing.cancel_request(&request_id).await; return Err(std::io::Error::other(format!( diff --git a/codex-rs/app-server/src/outgoing_message.rs b/codex-rs/app-server/src/outgoing_message.rs index 45f33b49d9..2d8b748c90 100644 --- a/codex-rs/app-server/src/outgoing_message.rs +++ b/codex-rs/app-server/src/outgoing_message.rs @@ -20,6 +20,8 @@ use crate::error_code::INTERNAL_ERROR_CODE; #[cfg(test)] use codex_protocol::account::PlanType; +pub(crate) type ClientRequestResult = std::result::Result; + /// Stable identifier for a transport connection. #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub(crate) struct ConnectionId(pub(crate) u64); @@ -46,7 +48,7 @@ pub(crate) enum OutgoingEnvelope { pub(crate) struct OutgoingMessageSender { next_server_request_id: AtomicI64, sender: mpsc::Sender, - request_id_to_callback: Mutex>>, + request_id_to_callback: Mutex>>, } #[derive(Clone)] @@ -69,7 +71,7 @@ impl ThreadScopedOutgoingMessageSender { pub(crate) async fn send_request( &self, payload: ServerRequestPayload, - ) -> oneshot::Receiver { + ) -> oneshot::Receiver { if self.connection_ids.is_empty() { let (_tx, rx) = oneshot::channel(); return rx; @@ -118,7 +120,7 @@ impl OutgoingMessageSender { &self, connection_ids: &[ConnectionId], request: ServerRequestPayload, - ) -> oneshot::Receiver { + ) -> oneshot::Receiver { let (_id, rx) = self .send_request_with_id_to_connections(connection_ids, request) .await; @@ -128,7 +130,7 @@ impl OutgoingMessageSender { pub(crate) async fn send_request_with_id( &self, request: ServerRequestPayload, - ) -> (RequestId, oneshot::Receiver) { + ) -> (RequestId, oneshot::Receiver) { self.send_request_with_id_to_connections(&[], request).await } @@ -136,7 +138,7 @@ impl OutgoingMessageSender { &self, connection_ids: &[ConnectionId], request: ServerRequestPayload, - ) -> (RequestId, oneshot::Receiver) { + ) -> (RequestId, oneshot::Receiver) { let id = RequestId::Integer(self.next_server_request_id.fetch_add(1, Ordering::Relaxed)); let outgoing_message_id = id.clone(); let (tx_approve, rx_approve) = oneshot::channel(); @@ -190,7 +192,7 @@ impl OutgoingMessageSender { match entry { Some((id, sender)) => { - if let Err(err) = sender.send(result) { + if let Err(err) = sender.send(Ok(result)) { warn!("could not notify callback for {id:?} due to: {err:?}"); } } @@ -207,8 +209,11 @@ impl OutgoingMessageSender { }; match entry { - Some((id, _sender)) => { + Some((id, sender)) => { warn!("client responded with error for {id:?}: {error:?}"); + if let Err(err) = sender.send(Err(error)) { + warn!("could not notify callback for {id:?} due to: {err:?}"); + } } None => { warn!("could not find callback for {id:?}"); @@ -390,11 +395,13 @@ mod tests { use codex_app_server_protocol::AccountLoginCompletedNotification; use codex_app_server_protocol::AccountRateLimitsUpdatedNotification; use codex_app_server_protocol::AccountUpdatedNotification; + use codex_app_server_protocol::ApplyPatchApprovalParams; use codex_app_server_protocol::AuthMode; use codex_app_server_protocol::ConfigWarningNotification; use codex_app_server_protocol::LoginChatGptCompleteNotification; use codex_app_server_protocol::RateLimitSnapshot; use codex_app_server_protocol::RateLimitWindow; + use codex_protocol::ThreadId; use pretty_assertions::assert_eq; use serde_json::json; use tokio::time::timeout; @@ -609,4 +616,38 @@ mod tests { other => panic!("expected targeted error envelope, got: {other:?}"), } } + + #[tokio::test] + async fn notify_client_error_forwards_error_to_waiter() { + let (tx, _rx) = mpsc::channel::(4); + let outgoing = OutgoingMessageSender::new(tx); + + let (request_id, wait_for_result) = outgoing + .send_request_with_id(ServerRequestPayload::ApplyPatchApproval( + ApplyPatchApprovalParams { + conversation_id: ThreadId::new(), + call_id: "call-id".to_string(), + file_changes: HashMap::new(), + reason: None, + grant_root: None, + }, + )) + .await; + + let error = JSONRPCErrorError { + code: INTERNAL_ERROR_CODE, + message: "refresh failed".to_string(), + data: None, + }; + + outgoing + .notify_client_error(request_id, error.clone()) + .await; + + let result = timeout(Duration::from_secs(1), wait_for_result) + .await + .expect("wait should not time out") + .expect("waiter should receive a callback"); + assert_eq!(result, Err(error)); + } } From f07f8b3ccd1ea1e4b42f69a9c2fd3488f30d0953 Mon Sep 17 00:00:00 2001 From: Michael Bolin Date: Thu, 12 Feb 2026 16:22:05 -0800 Subject: [PATCH 9/9] fix: reduce flakiness of compact_resume_after_second_compaction_preserves_history --- .../core/tests/suite/compact_resume_fork.rs | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-) diff --git a/codex-rs/core/tests/suite/compact_resume_fork.rs b/codex-rs/core/tests/suite/compact_resume_fork.rs index ff90d4baf4..fc77a2621f 100644 --- a/codex-rs/core/tests/suite/compact_resume_fork.rs +++ b/codex-rs/core/tests/suite/compact_resume_fork.rs @@ -932,9 +932,16 @@ async fn mount_second_compact_flow(server: &MockServer) -> Vec { ]); let sse7 = sse(vec![ev_completed("r7")]); + // Keep this matcher broad enough to survive prompt-shape differences across + // platforms/config (history may include either marker text or compact prompt + // fragments), but explicitly exclude the final resume turn so these two + // one-shot mocks cannot race for the same request. let match_second_compact = |req: &wiremock::Request| { let body = std::str::from_utf8(&req.body).unwrap_or(""); - body.contains("AFTER_FORK") + (body.contains("AFTER_FORK") + || body_contains_text(body, SUMMARIZATION_PROMPT) + || body.contains(&json_fragment(FIRST_REPLY))) + && !body.contains(&format!("\"text\":\"{AFTER_SECOND_RESUME}\"")) }; let second_compact = mount_sse_once_match(server, match_second_compact, sse6).await; @@ -984,7 +991,13 @@ async fn compact_conversation(conversation: &Arc) { .submit(Op::Compact) .await .expect("compact conversation"); - let warning_event = wait_for_event(conversation, |ev| matches!(ev, EventMsg::Warning(_))).await; + let warning_event = wait_for_event(conversation, |ev| { + matches!( + ev, + EventMsg::Warning(WarningEvent { message }) if message == COMPACT_WARNING_MESSAGE + ) + }) + .await; let EventMsg::Warning(WarningEvent { message }) = warning_event else { panic!("expected warning event after compact"); };