1use std::rc::Rc;
  2use std::sync::Arc;
  3use std::{any::Any, path::Path};
  4
  5use acp_thread::AgentConnection;
  6use agent_client_protocol as acp;
  7use anyhow::{Context as _, Result};
  8use fs::Fs;
  9use gpui::{App, AppContext as _, SharedString, Task};
 10use project::agent_server_store::{AllAgentServersSettings, CODEX_NAME};
 11use settings::{SettingsStore, update_settings_file};
 12
 13use crate::{AgentServer, AgentServerDelegate, load_proxy_env};
 14
 15#[derive(Clone)]
 16pub struct Codex;
 17
 18#[cfg(test)]
 19pub(crate) mod tests {
 20    use super::*;
 21
 22    crate::common_e2e_tests!(async |_, _, _| Codex, allow_option_id = "proceed_once");
 23}
 24
 25impl AgentServer for Codex {
 26    fn telemetry_id(&self) -> &'static str {
 27        "codex"
 28    }
 29
 30    fn name(&self) -> SharedString {
 31        "Codex".into()
 32    }
 33
 34    fn logo(&self) -> ui::IconName {
 35        ui::IconName::AiOpenAi
 36    }
 37
 38    fn default_mode(&self, cx: &mut App) -> Option<acp::SessionModeId> {
 39        let settings = cx.read_global(|settings: &SettingsStore, _| {
 40            settings.get::<AllAgentServersSettings>(None).codex.clone()
 41        });
 42
 43        settings
 44            .as_ref()
 45            .and_then(|s| s.default_mode.clone().map(|m| acp::SessionModeId(m.into())))
 46    }
 47
 48    fn set_default_mode(&self, mode_id: Option<acp::SessionModeId>, fs: Arc<dyn Fs>, cx: &mut App) {
 49        update_settings_file(fs, cx, |settings, _| {
 50            settings
 51                .agent_servers
 52                .get_or_insert_default()
 53                .codex
 54                .get_or_insert_default()
 55                .default_mode = mode_id.map(|m| m.to_string())
 56        });
 57    }
 58
 59    fn default_model(&self, cx: &mut App) -> Option<acp::ModelId> {
 60        let settings = cx.read_global(|settings: &SettingsStore, _| {
 61            settings.get::<AllAgentServersSettings>(None).codex.clone()
 62        });
 63
 64        settings
 65            .as_ref()
 66            .and_then(|s| s.default_model.clone().map(|m| acp::ModelId(m.into())))
 67    }
 68
 69    fn set_default_model(&self, model_id: Option<acp::ModelId>, fs: Arc<dyn Fs>, cx: &mut App) {
 70        update_settings_file(fs, cx, |settings, _| {
 71            settings
 72                .agent_servers
 73                .get_or_insert_default()
 74                .codex
 75                .get_or_insert_default()
 76                .default_model = model_id.map(|m| m.to_string())
 77        });
 78    }
 79
 80    fn connect(
 81        &self,
 82        root_dir: Option<&Path>,
 83        delegate: AgentServerDelegate,
 84        cx: &mut App,
 85    ) -> Task<Result<(Rc<dyn AgentConnection>, Option<task::SpawnInTerminal>)>> {
 86        let name = self.name();
 87        let telemetry_id = self.telemetry_id();
 88        let root_dir = root_dir.map(|root_dir| root_dir.to_string_lossy().into_owned());
 89        let is_remote = delegate.project.read(cx).is_via_remote_server();
 90        let store = delegate.store.downgrade();
 91        let extra_env = load_proxy_env(cx);
 92        let default_mode = self.default_mode(cx);
 93        let default_model = self.default_model(cx);
 94
 95        cx.spawn(async move |cx| {
 96            let (command, root_dir, login) = store
 97                .update(cx, |store, cx| {
 98                    let agent = store
 99                        .get_external_agent(&CODEX_NAME.into())
100                        .context("Codex is not registered")?;
101                    anyhow::Ok(agent.get_command(
102                        root_dir.as_deref(),
103                        extra_env,
104                        delegate.status_tx,
105                        delegate.new_version_available,
106                        &mut cx.to_async(),
107                    ))
108                })??
109                .await?;
110
111            let connection = crate::acp::connect(
112                name,
113                telemetry_id,
114                command,
115                root_dir.as_ref(),
116                default_mode,
117                default_model,
118                is_remote,
119                cx,
120            )
121            .await?;
122            Ok((connection, login))
123        })
124    }
125
126    fn into_any(self: Rc<Self>) -> Rc<dyn Any> {
127        self
128    }
129}