Add Cursor Composer 2.5 provider with CURSOR_API_KEY support.

lee101 · cursoragent · lee101 · commit e7513fe1e87d · 2026-05-28T09:41:25.000Z
Route composer-2.5 and composer-2.5-fast through openpaths or cursor based on env keys, load sibling openpaths/.env, and use Basic auth for the Cursor API.

Co-authored-by: Cursor &lt;cursoragent@cursor.com&gt;
diff --git a/codex-cli/scripts/deploy_new_binary.sh b/codex-cli/scripts/deploy_new_binary.sh
@@ -61,9 +61,18 @@ script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 codex_cli_root="$(cd "$script_dir/.." && pwd)"
 repo_root="$(cd "$codex_cli_root/.." && pwd)"
 codex_rs_root="$repo_root/codex-rs"
-binary_src="$codex_rs_root/target/release/codex"
 binary_dest="$codex_cli_root/vendor/x86_64-unknown-linux-gnu/codex/codex"
 
+if ! command -v "${CC:-cc}" >/dev/null 2>&1; then
+  if command -v gcc >/dev/null 2>&1; then
+    export CC=gcc
+    export CXX=g++
+  else
+    echo "error: gcc/cc is required to build tree-sitter; install build-essential." >&2
+    exit 1
+  fi
+fi
+
 if ((!dry_run)); then
   if ! (cd "$codex_cli_root" && npm whoami >/dev/null); then
     echo "error: npm is not authenticated; run npm login before deploying." >&2
@@ -73,6 +82,8 @@ fi
 
 cd "$codex_rs_root"
 cargo build --release -p codex-cli
+target_dir="$(cargo metadata --format-version 1 --no-deps | python3 -c "import json, sys; print(json.load(sys.stdin)['target_directory'])")"
+binary_src="$target_dir/release/codex"
 
 mkdir -p "$(dirname "$binary_dest")"
 install -m 755 "$binary_src" "$binary_dest"
diff --git a/codex-rs/Cargo.lock b/codex-rs/Cargo.lock
diff --git a/codex-rs/arg0/src/lib.rs b/codex-rs/arg0/src/lib.rs
@@ -241,13 +241,28 @@ fn build_runtime() -> anyhow::Result<tokio::runtime::Runtime> {
 
 const ILLEGAL_ENV_VAR_PREFIX: &str = "CODEX_";
 
-/// Load env vars from ~/.codex/.env.
+/// Load env vars from ~/.codex/.env and optional sibling `openpaths/.env`.
 ///
 /// Security: Do not allow `.env` files to create or modify any variables
 /// with names starting with `CODEX_`.
 fn load_dotenv() {
-    if let Ok(codex_home) = find_codex_home()
-        && let Ok(iter) = dotenvy::from_path_iter(codex_home.join(".env"))
+    if let Ok(codex_home) = find_codex_home() {
+        load_dotenv_file(&codex_home.join(".env"));
+    }
+
+    if let Ok(cwd) = std::env::current_dir() {
+        for candidate in [
+            cwd.join("openpaths").join(".env"),
+            cwd.join("../openpaths").join(".env"),
+        ] {
+            load_dotenv_file(&candidate);
+        }
+    }
+}
+
+fn load_dotenv_file(path: &std::path::Path) {
+    if path.is_file()
+        && let Ok(iter) = dotenvy::from_path_iter(path)
     {
         set_filtered(iter);
     }
diff --git a/codex-rs/core/src/model_family.rs b/codex-rs/core/src/model_family.rs
@@ -276,6 +276,16 @@ pub fn find_family_for_model(slug: &str) -> Option<ModelFamily> {
             slug, "openpaths-auto",
             needs_special_apply_patch_instructions: true,
         )
+    } else if slug == "composer-2.5"
+        || slug == "composer-2.5-fast"
+        || slug.starts_with("composer-2.5")
+        || slug.starts_with("openpaths/composer-2.5")
+        || slug.starts_with("cursor/composer-2.5")
+    {
+        model_family!(
+            slug, "composer-2.5",
+            needs_special_apply_patch_instructions: true,
+        )
     } else if slug.starts_with("glm-5") || slug.starts_with("GLM-5") {
         model_family!(
             slug, "glm-5",
diff --git a/codex-rs/model-provider-info/src/lib.rs b/codex-rs/model-provider-info/src/lib.rs
@@ -40,6 +40,8 @@ const OPENROUTER_PROVIDER_NAME: &str = "OpenRouter";
 pub const OPENROUTER_PROVIDER_ID: &str = "openrouter";
 const OPENPATHS_PROVIDER_NAME: &str = "OpenPaths";
 pub const OPENPATHS_PROVIDER_ID: &str = "openpaths";
+pub const CURSOR_PROVIDER_NAME: &str = "Cursor";
+pub const CURSOR_PROVIDER_ID: &str = "cursor";
 const ZHIPU_PROVIDER_NAME: &str = "Z.AI (Zhipu)";
 pub const ZHIPU_PROVIDER_ID: &str = "zhipu";
 const DEEPSEEK_PROVIDER_NAME: &str = "DeepSeek";
@@ -405,7 +407,7 @@ impl ModelProviderInfo {
     pub fn create_openpaths_provider() -> ModelProviderInfo {
         ModelProviderInfo {
             name: OPENPATHS_PROVIDER_NAME.into(),
-            base_url: Some("https://openpaths.io/v1".into()),
+            base_url: Some(openpaths_base_url()),
             env_key: Some("OPENPATHS_API_KEY".into()),
             env_key_instructions: Some(
                 "Get your API key from https://openpaths.io and set OPENPATHS_API_KEY".into(),
@@ -426,6 +428,31 @@ impl ModelProviderInfo {
         }
     }
 
+    pub fn create_cursor_provider() -> ModelProviderInfo {
+        ModelProviderInfo {
+            name: CURSOR_PROVIDER_NAME.into(),
+            base_url: Some(cursor_base_url()),
+            env_key: Some("CURSOR_API_KEY".into()),
+            env_key_instructions: Some(
+                "Get your API key from https://cursor.com/dashboard/integrations and set CURSOR_API_KEY"
+                    .into(),
+            ),
+            experimental_bearer_token: None,
+            auth: None,
+            wire_api: WireApi::Responses,
+            query_params: None,
+            http_headers: None,
+            env_http_headers: None,
+            request_max_retries: None,
+            stream_max_retries: None,
+            stream_idle_timeout_ms: None,
+            websocket_connect_timeout_ms: None,
+            requires_openai_auth: false,
+            supports_websockets: false,
+            ..Default::default()
+        }
+    }
+
     pub fn create_zhipu_provider() -> ModelProviderInfo {
         ModelProviderInfo {
             name: ZHIPU_PROVIDER_NAME.into(),
@@ -511,6 +538,8 @@ impl ModelProviderInfo {
             slug.strip_prefix("google/").unwrap_or(slug)
         } else if self.name == OPENPATHS_PROVIDER_NAME {
             slug.strip_prefix("openpaths/").unwrap_or(slug)
+        } else if self.name == CURSOR_PROVIDER_NAME {
+            slug.strip_prefix("cursor/").unwrap_or(slug)
         } else if self.name == ZHIPU_PROVIDER_NAME {
             slug.strip_prefix("zhipu/")
                 .or_else(|| slug.strip_prefix("z-ai/"))
@@ -556,6 +585,7 @@ pub fn built_in_model_providers(
         (OPENAI_PROVIDER_ID, openai_provider),
         (OPENROUTER_PROVIDER_ID, P::create_openrouter_provider()),
         (OPENPATHS_PROVIDER_ID, P::create_openpaths_provider()),
+        (CURSOR_PROVIDER_ID, P::create_cursor_provider()),
         (GEMINI_PROVIDER_ID, P::create_gemini_provider()),
         (ZHIPU_PROVIDER_ID, P::create_zhipu_provider()),
         (DEEPSEEK_PROVIDER_ID, P::create_deepseek_provider()),
@@ -580,6 +610,39 @@ fn non_empty_env_var(name: &str) -> bool {
         .is_some_and(|value| !value.trim().is_empty())
 }
 
+fn openpaths_base_url() -> String {
+    std::env::var("OPENPATHS_BASE_URL")
+        .ok()
+        .filter(|value| !value.trim().is_empty())
+        .map(|value| {
+            let trimmed = value.trim().trim_end_matches('/');
+            if trimmed.ends_with("/v1") {
+                trimmed.to_string()
+            } else {
+                format!("{trimmed}/v1")
+            }
+        })
+        .unwrap_or_else(|| "https://openpaths.io/v1".to_string())
+}
+
+fn cursor_base_url() -> String {
+    std::env::var("CURSOR_BASE_URL")
+        .ok()
+        .filter(|value| !value.trim().is_empty())
+        .map(|value| value.trim().trim_end_matches('/').to_string())
+        .unwrap_or_else(|| "https://api.cursor.com".to_string())
+}
+
+fn is_composer_model_slug(lower: &str) -> bool {
+    let slug = lower
+        .strip_prefix("openpaths/")
+        .or_else(|| lower.strip_prefix("cursor/"))
+        .unwrap_or(lower);
+    slug == "composer-2.5"
+        || slug == "composer-2.5-fast"
+        || slug.starts_with("composer-2.5-")
+}
+
 pub fn infer_builtin_provider_id_for_model(model: &str) -> Option<&'static str> {
     let lower = model.to_lowercase();
     if (lower.starts_with("glm-")
@@ -611,6 +674,14 @@ pub fn infer_builtin_provider_id_for_model(model: &str) -> Option<&'static str>
     {
         return Some(OPENPATHS_PROVIDER_ID);
     }
+    if is_composer_model_slug(&lower) {
+        if non_empty_env_var("OPENPATHS_API_KEY") {
+            return Some(OPENPATHS_PROVIDER_ID);
+        }
+        if non_empty_env_var("CURSOR_API_KEY") {
+            return Some(CURSOR_PROVIDER_ID);
+        }
+    }
     match model.split_once('/') {
         Some(("google", _)) if non_empty_env_var("GEMINI_API_KEY") => Some(GEMINI_PROVIDER_ID),
         Some(("google", _)) if non_empty_env_var("OPENROUTER_API_KEY") => {
@@ -623,6 +694,7 @@ pub fn infer_builtin_provider_id_for_model(model: &str) -> Option<&'static str>
         Some(("openpaths", _)) if non_empty_env_var("OPENPATHS_API_KEY") => {
             Some(OPENPATHS_PROVIDER_ID)
         }
+        Some(("cursor", _)) if non_empty_env_var("CURSOR_API_KEY") => Some(CURSOR_PROVIDER_ID),
         Some(("deepseek", _)) if non_empty_env_var("DEEPSEEK_API_KEY") => {
             Some(DEEPSEEK_PROVIDER_ID)
         }
diff --git a/codex-rs/model-provider-info/src/model_provider_info_tests.rs b/codex-rs/model-provider-info/src/model_provider_info_tests.rs
@@ -278,12 +278,30 @@ fn openpaths_provider_normalizes_openpaths_prefix() {
         provider.effective_model_name("auto-medium-task"),
         "auto-medium-task"
     );
+    assert_eq!(
+        provider.effective_model_name("openpaths/composer-2.5-fast"),
+        "composer-2.5-fast"
+    );
+}
+
+#[test]
+fn cursor_provider_normalizes_cursor_prefix() {
+    let provider = ModelProviderInfo::create_cursor_provider();
+    assert_eq!(
+        provider.effective_model_name("cursor/composer-2.5-fast"),
+        "composer-2.5-fast"
+    );
+    assert_eq!(
+        provider.effective_model_name("composer-2.5"),
+        "composer-2.5"
+    );
 }
 
 #[test]
 fn infer_builtin_provider_prefers_env_backed_routes() {
     let _gemini_remove_guard = EnvVarGuard::remove("GEMINI_API_KEY");
     let _openrouter_remove_guard = EnvVarGuard::remove("OPENROUTER_API_KEY");
+    let _cursor_remove_guard = EnvVarGuard::remove("CURSOR_API_KEY");
     let openpaths_remove_guard = EnvVarGuard::remove("OPENPATHS_API_KEY");
     assert_eq!(
         infer_builtin_provider_id_for_model("google/gemini-3.1-pro-preview"),
@@ -331,6 +349,25 @@ fn infer_builtin_provider_prefers_env_backed_routes() {
         infer_builtin_provider_id_for_model("openpaths/auto-think"),
         Some(OPENPATHS_PROVIDER_ID)
     );
+    assert_eq!(
+        infer_builtin_provider_id_for_model("composer-2.5"),
+        Some(OPENPATHS_PROVIDER_ID)
+    );
+    assert_eq!(
+        infer_builtin_provider_id_for_model("composer-2.5-fast"),
+        Some(OPENPATHS_PROVIDER_ID)
+    );
+
+    drop(_openpaths_set_guard);
+    let _cursor_set_guard = EnvVarGuard::set("CURSOR_API_KEY", "cursor-key");
+    assert_eq!(
+        infer_builtin_provider_id_for_model("composer-2.5"),
+        Some(CURSOR_PROVIDER_ID)
+    );
+    assert_eq!(
+        infer_builtin_provider_id_for_model("cursor/composer-2.5-fast"),
+        Some(CURSOR_PROVIDER_ID)
+    );
 }
 
 #[test]
diff --git a/codex-rs/model-provider/Cargo.toml b/codex-rs/model-provider/Cargo.toml
@@ -14,6 +14,7 @@ workspace = true
 
 [dependencies]
 async-trait = { workspace = true }
+base64 = { workspace = true }
 codex-api = { workspace = true }
 codex-agent-identity = { workspace = true }
 codex-aws-auth = { workspace = true }
diff --git a/codex-rs/model-provider/src/auth.rs b/codex-rs/model-provider/src/auth.rs
@@ -11,7 +11,9 @@ use codex_model_provider_info::ModelProviderInfo;
 use http::HeaderMap;
 use http::HeaderValue;
 
+use crate::basic_auth_provider::BasicAuthProvider;
 use crate::bearer_auth_provider::BearerAuthProvider;
+use codex_model_provider_info::CURSOR_PROVIDER_NAME;
 
 #[derive(Clone, Debug)]
 struct AgentIdentityAuthProvider {
@@ -79,6 +81,12 @@ pub(crate) fn resolve_provider_auth(
     auth: Option<&CodexAuth>,
     provider: &ModelProviderInfo,
 ) -> codex_protocol::error::Result<SharedAuthProvider> {
+    if provider.name == CURSOR_PROVIDER_NAME
+        && let Some(api_key) = provider.api_key()?
+    {
+        return Ok(Arc::new(BasicAuthProvider::new(api_key)));
+    }
+
     if let Some(auth) = bearer_auth_for_provider(provider)? {
         return Ok(Arc::new(auth));
     }
@@ -92,6 +100,10 @@ pub(crate) fn resolve_provider_auth(
 fn bearer_auth_for_provider(
     provider: &ModelProviderInfo,
 ) -> codex_protocol::error::Result<Option<BearerAuthProvider>> {
+    if provider.name == CURSOR_PROVIDER_NAME {
+        return Ok(None);
+    }
+
     if let Some(api_key) = provider.api_key()? {
         return Ok(Some(BearerAuthProvider::new(api_key)));
     }
diff --git a/codex-rs/model-provider/src/basic_auth_provider.rs b/codex-rs/model-provider/src/basic_auth_provider.rs
@@ -0,0 +1,47 @@
+use base64::Engine;
+use base64::engine::general_purpose::STANDARD as BASE64_STANDARD;
+use codex_api::AuthProvider;
+use http::HeaderMap;
+use http::HeaderValue;
+
+/// Basic auth provider for APIs that expect `Authorization: Basic <base64(api_key:)>` headers.
+#[derive(Clone)]
+pub struct BasicAuthProvider {
+    api_key: String,
+}
+
+impl BasicAuthProvider {
+    pub fn new(api_key: String) -> Self {
+        Self { api_key }
+    }
+}
+
+impl AuthProvider for BasicAuthProvider {
+    fn add_auth_headers(&self, headers: &mut HeaderMap) {
+        let encoded = BASE64_STANDARD.encode(format!("{}:", self.api_key));
+        if let Ok(header) = HeaderValue::from_str(&format!("Basic {encoded}")) {
+            let _ = headers.insert(http::header::AUTHORIZATION, header);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use pretty_assertions::assert_eq;
+
+    #[test]
+    fn basic_auth_provider_adds_auth_header() {
+        let auth = BasicAuthProvider::new("cursor-test-key".to_string());
+        let mut headers = HeaderMap::new();
+
+        auth.add_auth_headers(&mut headers);
+
+        assert_eq!(
+            headers
+                .get(http::header::AUTHORIZATION)
+                .and_then(|value| value.to_str().ok()),
+            Some("Basic Y3Vyc29yLXRlc3Qta2V5Og==")
+        );
+    }
+}
diff --git a/codex-rs/model-provider/src/lib.rs b/codex-rs/model-provider/src/lib.rs
@@ -1,5 +1,6 @@
 mod amazon_bedrock;
 mod auth;
+mod basic_auth_provider;
 mod bearer_auth_provider;
 mod models_endpoint;
 mod provider;
