Use explicit code mode session provider selection

codex-rs/code-mode/src/lib.rs

@@ -39,6 +39,7 @@ pub use service::CodeModeSessionResultFuture;
 pub use service::InProcessCodeModeSessionProvider;
 pub use service::NoopCodeModeSessionDelegate;
 pub use service::NotificationFuture;
+pub use service::SessionProviderSelection;
 pub use service::StartedCell;
 pub use service::ToolInvocationFuture;
 

codex-rs/code-mode/src/service.rs

@@ -156,6 +156,31 @@ pub trait CodeModeSessionProvider: Send + Sync {
     ) -> CodeModeSessionProviderFuture<'a>;
 }
 
+/// Selects how a code-mode session is provisioned for a Codex session.
+#[derive(Clone, Default)]
+pub enum SessionProviderSelection {
+    #[default]
+    InProcess,
+    Disabled,
+    Custom(Arc<dyn CodeModeSessionProvider>),
+}
+
+impl SessionProviderSelection {
+    pub async fn create_session(
+        &self,
+        delegate: Arc<dyn CodeModeSessionDelegate>,
+    ) -> Result<Option<Arc<dyn CodeModeSession>>, String> {
+        match self {
+            Self::InProcess => InProcessCodeModeSessionProvider
+                .create_session(delegate)
+                .await
+                .map(Some),
+            Self::Disabled => Ok(None),
+            Self::Custom(provider) => provider.create_session(delegate).await.map(Some),
+        }
+    }
+}
+
 #[derive(Default)]
 pub struct InProcessCodeModeSessionProvider;
 
@@ -870,6 +895,7 @@ mod tests {
     use super::PendingRuntimeMode;
     use super::RuntimeCommand;
     use super::RuntimeResponse;
+    use super::SessionProviderSelection;
     use super::WaitOutcome;
     use super::WaitRequest;
     use super::WaitToPendingOutcome;
@@ -943,6 +969,26 @@ mod tests {
         );
     }
 
+    #[tokio::test]
+    async fn provider_selection_defaults_to_in_process_and_can_disable() {
+        let delegate = Arc::new(NoopCodeModeSessionDelegate);
+
+        assert!(
+            SessionProviderSelection::default()
+                .create_session(delegate.clone())
+                .await
+                .unwrap()
+                .is_some()
+        );
+        assert!(
+            SessionProviderSelection::Disabled
+                .create_session(delegate)
+                .await
+                .unwrap()
+                .is_none()
+        );
+    }
+
     #[tokio::test]
     async fn stored_values_are_shared_between_cells_but_not_sessions() {
         let first_session = CodeModeService::new();