feat: fallback unified_exec to shell_command

Author: jif-oai

codex-rs/core/src/codex.rs

@@ -32,6 +32,7 @@ use async_channel::Sender;
 use codex_protocol::ConversationId;
 use codex_protocol::approvals::ExecPolicyAmendment;
 use codex_protocol::items::TurnItem;
+use codex_protocol::openai_models::ConfigShellToolType;
 use codex_protocol::protocol::FileChange;
 use codex_protocol::protocol::HasLegacyEvent;
 use codex_protocol::protocol::ItemCompletedEvent;
@@ -880,6 +881,21 @@ impl Session {
             self.conversation_id,
             sub_id,
         );
+        // Check if `unified_exec` is supported by the OS. Fallback on ShellCommand otherwise.
+        if matches!(
+            turn_context.tools_config.shell_type,
+            ConfigShellToolType::UnifiedExec
+        ) {
+            let hb_command = self.user_shell().derive_exec_args("exit 0", false);
+            if !self
+                .services
+                .unified_exec_manager
+                .unified_exec_available(&hb_command)
+                .await
+            {
+                turn_context.tools_config.shell_type = ConfigShellToolType::ShellCommand;
+            }
+        }
         if let Some(final_schema) = updates.final_output_json_schema {
             turn_context.final_output_json_schema = final_schema;
         }

codex-rs/core/src/unified_exec/mod.rs

@@ -135,12 +135,14 @@ impl SessionStore {
 
 pub(crate) struct UnifiedExecSessionManager {
     session_store: Mutex<SessionStore>,
+    availability: Mutex<Option<bool>>,
 }
 
 impl Default for UnifiedExecSessionManager {
     fn default() -> Self {
         Self {
             session_store: Mutex::new(SessionStore::default()),
+            availability: Mutex::new(None),
         }
     }
 }

codex-rs/core/src/unified_exec/session_manager.rs

@@ -9,6 +9,7 @@ use tokio::sync::mpsc;
 use tokio::time::Duration;
 use tokio::time::Instant;
 use tokio_util::sync::CancellationToken;
+use tracing::warn;
 
 use crate::bash::extract_bash_command;
 use crate::codex::Session;
@@ -78,6 +79,41 @@ struct PreparedSessionHandles {
 }
 
 impl UnifiedExecSessionManager {
+    pub(crate) async fn unified_exec_available(&self, command: &[String]) -> bool {
+        {
+            let availability = self.availability.lock().await;
+            if let Some(available) = *availability {
+                return available;
+            }
+        }
+
+        let available = Self::probe_unified_exec_heartbeat(command).await;
+
+        let mut availability = self.availability.lock().await;
+        *availability = Some(available);
+        available
+    }
+
+    async fn probe_unified_exec_heartbeat(command: &[String]) -> bool {
+        let Some((program, args)) = command.split_first() else {
+            warn!("unified exec heartbeat failed: missing command");
+            return false;
+        };
+        let cwd = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
+        let env = HashMap::new();
+
+        match codex_utils_pty::spawn_pty_process(program, args, &cwd, &env, &None).await {
+            Ok(spawned) => {
+                spawned.session.terminate();
+                true
+            }
+            Err(err) => {
+                warn!("unified exec heartbeat failed; falling back to other tool: {err:#}");
+                false
+            }
+        }
+    }
+
     pub(crate) async fn allocate_process_id(&self) -> String {
         loop {
             let mut store = self.session_store.lock().await;