fix: reconcile upstream picks with local APIs

Adapts selected upstream changes to this branch's existing tool, TUI, and exec-server APIs after scoped lint validation.

Co-authored-by: Codex <noreply@openai.com>

Author: ericjuta

codex-rs/core/src/tools/handlers/apply_patch_tests.rs

@@ -9,6 +9,7 @@ use codex_protocol::protocol::SandboxPolicy;
 use core_test_support::PathBufExt;
 use core_test_support::PathExt;
 use pretty_assertions::assert_eq;
+use serde_json::json;
 use std::sync::Arc;
 use tempfile::TempDir;
 use tokio::sync::Mutex;

codex-rs/core/src/tools/handlers/unified_exec_tests.rs

@@ -424,18 +424,19 @@ async fn write_stdin_post_tool_use_payload_keeps_parallel_session_metadata_separ
         hook_command: Some("sleep 1; echo beta".to_string()),
     };
 
-    let (session, turn) = make_session_and_context().await;
+    let (session_b, turn_b) = make_session_and_context().await;
     let invocation_b = ToolInvocation {
-        session: session.clone().into(),
-        turn: turn.clone().into(),
+        session: session_b.into(),
+        turn: turn_b.into(),
         tracker: Arc::new(Mutex::new(TurnDiffTracker::new())),
         call_id: "write-call-b".to_string(),
         tool_name: codex_tools::ToolName::plain("exec_command"),
         payload: payload.clone(),
     };
+    let (session_a, turn_a) = make_session_and_context().await;
     let invocation_a = ToolInvocation {
-        session: session.into(),
-        turn: turn.into(),
+        session: session_a.into(),
+        turn: turn_a.into(),
         tracker: Arc::new(Mutex::new(TurnDiffTracker::new())),
         call_id: "write-call-a".to_string(),
         tool_name: codex_tools::ToolName::plain("exec_command"),

codex-rs/core/src/tools/registry.rs

@@ -239,9 +239,10 @@ where
         Box::pin(async move {
             let call_id = invocation.call_id.clone();
             let payload = invocation.payload.clone();
+            let post_tool_invocation = invocation.clone();
             let output = self.handle(invocation).await?;
             let post_tool_use_payload =
-                ToolHandler::post_tool_use_payload(self, &call_id, &payload, &output);
+                ToolHandler::post_tool_use_payload(self, &post_tool_invocation, &output);
             Ok(AnyToolResult {
                 call_id,
                 payload,

codex-rs/exec-server/src/local_process.rs

@@ -704,7 +704,6 @@ fn notification_sender(inner: &Inner) -> Option<RpcNotificationSender> {
 mod tests {
     use super::*;
     use codex_config::types::ShellEnvironmentPolicyInherit;
-    use codex_utils_pty::ProcessDriver;
     use pretty_assertions::assert_eq;
     use tokio::sync::oneshot;
     use tokio::time::timeout;
@@ -875,7 +874,7 @@ mod tests {
         let previous = processes.insert(
             process_id.clone(),
             ProcessEntry::Running(Box::new(RunningProcess {
-                session: dummy_session(),
+                session: dummy_session().await,
                 tty: false,
                 pipe_stdin: false,
                 output: VecDeque::new(),
@@ -921,21 +920,16 @@ mod tests {
         }
     }
 
-    fn dummy_session() -> ExecCommandSession {
-        let (writer_tx, _writer_rx) = mpsc::channel(1);
-        let (_stdout_tx, stdout_rx) = tokio::sync::broadcast::channel(1);
-        let (_stderr_tx, stderr_rx) = tokio::sync::broadcast::channel(1);
-        let (_exit_tx, exit_rx) = oneshot::channel();
-
-        codex_utils_pty::spawn_from_driver(ProcessDriver {
-            writer_tx,
-            stdout_rx,
-            stderr_rx: Some(stderr_rx),
-            exit_rx,
-            terminator: None,
-            writer_handle: None,
-            resizer: None,
-        })
+    async fn dummy_session() -> ExecCommandSession {
+        codex_utils_pty::spawn_pipe_process_no_stdin(
+            "true",
+            &[],
+            std::path::Path::new("/tmp"),
+            &HashMap::new(),
+            &None,
+        )
+        .await
+        .expect("spawn dummy process")
         .session
     }
 

codex-rs/tools/src/tool_config_tests.rs

@@ -225,6 +225,7 @@ fn memory_tool_defaults_to_native_backend_and_feature_flag() {
         model_info: &model_info,
         available_models: &available_models,
         features: &features,
+        image_generation_tool_auth_allowed: true,
         web_search_mode: Some(WebSearchMode::Cached),
         session_source: SessionSource::Cli,
         sandbox_policy: &SandboxPolicy::DangerFullAccess,
@@ -244,6 +245,7 @@ fn memory_backend_override_is_retained() {
         model_info: &model_info,
         available_models: &available_models,
         features: &features,
+        image_generation_tool_auth_allowed: true,
         web_search_mode: Some(WebSearchMode::Cached),
         session_source: SessionSource::Cli,
         sandbox_policy: &SandboxPolicy::DangerFullAccess,

codex-rs/tui/src/app/thread_session_state.rs

@@ -50,117 +50,3 @@ impl App {
         session
     }
 }
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::app::side::SideThreadState;
-    use crate::app::test_support::make_test_app;
-    use crate::app::thread_events::ThreadEventChannel;
-    use crate::test_support::PathBufExt;
-    use crate::test_support::test_path_buf;
-    use codex_config::types::ApprovalsReviewer;
-    use codex_protocol::protocol::AskForApproval;
-    use codex_protocol::protocol::SandboxPolicy;
-    use pretty_assertions::assert_eq;
-    use std::path::PathBuf;
-
-    fn test_thread_session(thread_id: ThreadId, cwd: PathBuf) -> ThreadSessionState {
-        ThreadSessionState {
-            thread_id,
-            forked_from_id: None,
-            fork_parent_title: None,
-            thread_name: None,
-            model: "gpt-test".to_string(),
-            model_provider_id: "test-provider".to_string(),
-            service_tier: None,
-            approval_policy: AskForApproval::Never,
-            approvals_reviewer: ApprovalsReviewer::User,
-            sandbox_policy: SandboxPolicy::new_read_only_policy(),
-            cwd: cwd.abs(),
-            instruction_source_paths: Vec::new(),
-            reasoning_effort: None,
-            history_log_id: 0,
-            history_entry_count: 0,
-            network_proxy: None,
-            rollout_path: Some(PathBuf::new()),
-        }
-    }
-
-    #[tokio::test]
-    async fn permission_settings_sync_updates_active_snapshot_without_rewriting_side_thread() {
-        let mut app = make_test_app().await;
-        let main_thread_id =
-            ThreadId::from_string("00000000-0000-0000-0000-000000000401").expect("valid thread");
-        let side_thread_id =
-            ThreadId::from_string("00000000-0000-0000-0000-000000000402").expect("valid thread");
-        let main_session = test_thread_session(main_thread_id, test_path_buf("/tmp/main"));
-        let side_session = ThreadSessionState {
-            approval_policy: AskForApproval::OnRequest,
-            sandbox_policy: SandboxPolicy::new_workspace_write_policy(),
-            ..test_thread_session(side_thread_id, test_path_buf("/tmp/side"))
-        };
-
-        app.primary_thread_id = Some(main_thread_id);
-        app.active_thread_id = Some(main_thread_id);
-        app.primary_session_configured = Some(main_session.clone());
-        app.thread_event_channels.insert(
-            main_thread_id,
-            ThreadEventChannel::new_with_session(
-                /*capacity*/ 4,
-                main_session.clone(),
-                Vec::new(),
-            ),
-        );
-        app.thread_event_channels.insert(
-            side_thread_id,
-            ThreadEventChannel::new_with_session(
-                /*capacity*/ 4,
-                side_session.clone(),
-                Vec::new(),
-            ),
-        );
-        app.side_threads
-            .insert(side_thread_id, SideThreadState::new(main_thread_id));
-        app.config.permissions.approval_policy =
-            codex_config::Constrained::allow_any(AskForApproval::OnRequest);
-        app.config.approvals_reviewer = ApprovalsReviewer::GuardianSubagent;
-        app.config.permissions.sandbox_policy =
-            codex_config::Constrained::allow_any(SandboxPolicy::new_workspace_write_policy());
-
-        app.sync_active_thread_permission_settings_to_cached_session()
-            .await;
-
-        let expected_main_session = ThreadSessionState {
-            approval_policy: AskForApproval::OnRequest,
-            approvals_reviewer: ApprovalsReviewer::GuardianSubagent,
-            sandbox_policy: SandboxPolicy::new_workspace_write_policy(),
-            ..main_session
-        };
-        assert_eq!(
-            app.primary_session_configured,
-            Some(expected_main_session.clone())
-        );
-
-        let main_store_session = app
-            .thread_event_channels
-            .get(&main_thread_id)
-            .expect("main thread channel")
-            .store
-            .lock()
-            .await
-            .session
-            .clone();
-        assert_eq!(main_store_session, Some(expected_main_session));
-
-        let side_store_session = app
-            .thread_event_channels
-            .get(&side_thread_id)
-            .expect("side thread channel")
-            .store
-            .lock()
-            .await
-            .session
-            .clone();
-        assert_eq!(side_store_session, Some(side_session));
-    }
-}