fix

codex-rs/app-server/src/codex_message_processor.rs

@@ -21,7 +21,6 @@ use codex_app_server_protocol::AppsListParams;
 use codex_app_server_protocol::AppsListResponse;
 use codex_app_server_protocol::ArchiveConversationParams;
 use codex_app_server_protocol::ArchiveConversationResponse;
-use codex_app_server_protocol::AskForApproval;
 use codex_app_server_protocol::AuthMode;
 use codex_app_server_protocol::AuthStatusChangeNotification;
 use codex_app_server_protocol::CancelLoginAccountParams;
@@ -429,6 +428,56 @@ impl CodexMessageProcessor {
         collaboration_mode
     }
 
+    fn merge_turn_start_with_config(
+        &self,
+        turn_start_params: TurnStartParams,
+        config_snapshot: ThreadConfigSnapshot,
+    ) -> Op {
+        let TurnStartParams {
+            thread_id: _,
+            cwd,
+            approval_policy,
+            sandbox_policy,
+            model,
+            effort,
+            summary,
+            collaboration_mode,
+            personality,
+            input,
+            output_schema,
+        } = turn_start_params;
+
+        // Map v2 input items to core input items.
+        let items: Vec<CoreInputItem> = input.into_iter().map(V2UserInput::into_core).collect();
+
+        let collaboration_mode = collaboration_mode
+            .map(|mode| self.normalize_turn_start_collaboration_mode(mode))
+            .or_else(|| {
+                Some(config_snapshot.collaboration_mode.with_updates(
+                    model.clone(),
+                    effort.map(Some),
+                    None,
+                ))
+            });
+
+        Op::UserTurn {
+            items,
+            cwd: cwd.unwrap_or(config_snapshot.cwd),
+            approval_policy: approval_policy
+                .map(codex_app_server_protocol::AskForApproval::to_core)
+                .unwrap_or(config_snapshot.approval_policy),
+            sandbox_policy: sandbox_policy
+                .map(|p| p.to_core())
+                .unwrap_or(config_snapshot.sandbox_policy),
+            model: model.unwrap_or(config_snapshot.model),
+            effort: effort.or(config_snapshot.reasoning_effort),
+            summary: summary.unwrap_or(config_snapshot.reasoning_summary),
+            final_output_json_schema: output_schema,
+            collaboration_mode,
+            personality,
+        }
+    }
+
     fn review_request_from_target(
         target: ApiReviewTarget,
     ) -> Result<(ReviewRequest, String), JSONRPCErrorError> {
@@ -4734,51 +4783,10 @@ impl CodexMessageProcessor {
                 return;
             }
         };
-
-        let collaboration_mode = params
-            .collaboration_mode
-            .map(|mode| self.normalize_turn_start_collaboration_mode(mode));
-
-        // Map v2 input items to core input items.
-        let mapped_items: Vec<CoreInputItem> = params
-            .input
-            .into_iter()
-            .map(V2UserInput::into_core)
-            .collect();
-
-        let has_any_overrides = params.cwd.is_some()
-            || params.approval_policy.is_some()
-            || params.sandbox_policy.is_some()
-            || params.model.is_some()
-            || params.effort.is_some()
-            || params.summary.is_some()
-            || collaboration_mode.is_some()
-            || params.personality.is_some();
-
-        // If any overrides are provided, update the session turn context first.
-        if has_any_overrides {
-            let _ = thread
-                .submit(Op::OverrideTurnContext {
-                    cwd: params.cwd,
-                    approval_policy: params.approval_policy.map(AskForApproval::to_core),
-                    sandbox_policy: params.sandbox_policy.map(|p| p.to_core()),
-                    windows_sandbox_level: None,
-                    model: params.model,
-                    effort: params.effort.map(Some),
-                    summary: params.summary,
-                    collaboration_mode,
-                    personality: params.personality,
-                })
-                .await;
-        }
-
-        // Start the turn by submitting the user input. Return its submission id as turn_id.
-        let turn_id = thread
-            .submit(Op::UserInput {
-                items: mapped_items,
-                final_output_json_schema: params.output_schema,
-            })
-            .await;
+        let thread_id = params.thread_id.clone();
+        let config_snapshot = thread.config_snapshot().await;
+        let op_user_turn = self.merge_turn_start_with_config(params, config_snapshot);
+        let turn_id = thread.submit(op_user_turn).await;
 
         match turn_id {
             Ok(turn_id) => {
@@ -4793,10 +4801,7 @@ impl CodexMessageProcessor {
                 self.outgoing.send_response(request_id, response).await;
 
                 // Emit v2 turn/started notification.
-                let notif = TurnStartedNotification {
-                    thread_id: params.thread_id,
-                    turn,
-                };
+                let notif = TurnStartedNotification { thread_id, turn };
                 self.outgoing
                     .send_server_notification(ServerNotification::TurnStarted(notif))
                     .await;

codex-rs/core/src/codex.rs

@@ -651,7 +651,9 @@ impl SessionConfiguration {
             approval_policy: self.approval_policy.value(),
             sandbox_policy: self.sandbox_policy.get().clone(),
             cwd: self.cwd.clone(),
+            collaboration_mode: self.collaboration_mode.clone(),
             reasoning_effort: self.collaboration_mode.reasoning_effort(),
+            reasoning_summary: self.model_reasoning_summary,
             personality: self.personality,
             session_source: self.session_source.clone(),
         }

codex-rs/core/src/codex_thread.rs

@@ -5,7 +5,9 @@ use crate::error::Result as CodexResult;
 use crate::protocol::Event;
 use crate::protocol::Op;
 use crate::protocol::Submission;
+use codex_protocol::config_types::CollaborationMode;
 use codex_protocol::config_types::Personality;
+use codex_protocol::config_types::ReasoningSummary;
 use codex_protocol::openai_models::ReasoningEffort;
 use codex_protocol::protocol::AskForApproval;
 use codex_protocol::protocol::SandboxPolicy;
@@ -23,7 +25,9 @@ pub struct ThreadConfigSnapshot {
     pub approval_policy: AskForApproval,
     pub sandbox_policy: SandboxPolicy,
     pub cwd: PathBuf,
+    pub collaboration_mode: CollaborationMode,
     pub reasoning_effort: Option<ReasoningEffort>,
+    pub reasoning_summary: ReasoningSummary,
     pub personality: Option<Personality>,
     pub session_source: SessionSource,
 }