Skip to content

Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy

Rust

add native cursor provider core

Raine Virta57b5e0a7f9e2
diff --git a/Cargo.lock b/Cargo.lock
index 8ee8424..bb31f48 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2,6 +2,12 @@
# It is not intended for manual editing.
version = 4
+[[package]]
+name = "adler2"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
+
[[package]]
name = "aho-corasick"
version = "1.1.4"
@@ -292,13 +298,16 @@ dependencies = [
"base64",
"bytes",
"clap",
+ "flate2",
"futures-core",
"futures-util",
+ "hex",
"hostname",
"http",
"http-body-util",
"once_cell",
"predicates",
+ "prost",
"regex-lite",
"reqwest",
"serde",
@@ -346,6 +355,15 @@ dependencies = [
"libc",
]
+[[package]]
+name = "crc32fast"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
+dependencies = [
+ "cfg-if",
+]
+
[[package]]
name = "crypto-common"
version = "0.1.7"
@@ -395,6 +413,18 @@ dependencies = [
"syn",
]
+[[package]]
+name = "either"
+version = "1.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91622ff5e7162018101f2fea40d6ebf4a78bbe5a49736a2020649edf9693679e"
+
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
[[package]]
name = "errno"
version = "0.3.14"
@@ -417,6 +447,16 @@ version = "0.1.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
+[[package]]
+name = "flate2"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c"
+dependencies = [
+ "crc32fast",
+ "miniz_oxide",
+]
+
[[package]]
name = "float-cmp"
version = "0.10.0"
@@ -426,6 +466,12 @@ dependencies = [
"num-traits",
]
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
[[package]]
name = "form_urlencoded"
version = "1.2.2"
@@ -544,12 +590,43 @@ dependencies = [
"r-efi 6.0.0",
]
+[[package]]
+name = "h2"
+version = "0.4.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6cb093c84e8bd9b188d4c4a8cb6579fc016968d14c99882163cd3ff402a4f155"
+dependencies = [
+ "atomic-waker",
+ "bytes",
+ "fnv",
+ "futures-core",
+ "futures-sink",
+ "http",
+ "indexmap",
+ "slab",
+ "tokio",
+ "tokio-util",
+ "tracing",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.17.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
+
[[package]]
name = "heck"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+[[package]]
+name = "hex"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+
[[package]]
name = "hostname"
version = "0.4.2"
@@ -616,6 +693,7 @@ dependencies = [
"bytes",
"futures-channel",
"futures-core",
+ "h2",
"http",
"http-body",
"httparse",
@@ -769,6 +847,16 @@ dependencies = [
"icu_properties",
]
+[[package]]
+name = "indexmap"
+version = "2.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9"
+dependencies = [
+ "equivalent",
+ "hashbrown",
+]
+
[[package]]
name = "ipnet"
version = "2.12.0"
@@ -781,6 +869,15 @@ version = "1.70.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
+[[package]]
+name = "itertools"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
+dependencies = [
+ "either",
+]
+
[[package]]
name = "itoa"
version = "1.0.18"
@@ -861,6 +958,16 @@ version = "0.3.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
+[[package]]
+name = "miniz_oxide"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
+dependencies = [
+ "adler2",
+ "simd-adler32",
+]
+
[[package]]
name = "mio"
version = "1.2.1"
@@ -995,6 +1102,29 @@ dependencies = [
"unicode-ident",
]
+[[package]]
+name = "prost"
+version = "0.13.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2796faa41db3ec313a31f7624d9286acf277b52de526150b7e69f3debf891ee5"
+dependencies = [
+ "bytes",
+ "prost-derive",
+]
+
+[[package]]
+name = "prost-derive"
+version = "0.13.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a56d757972c98b346a9b766e3f02746cde6dd1cd1d1d563472929fdd74bec4d"
+dependencies = [
+ "anyhow",
+ "itertools",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
[[package]]
name = "quinn"
version = "0.11.11"
@@ -1176,6 +1306,7 @@ dependencies = [
"futures-channel",
"futures-core",
"futures-util",
+ "h2",
"http",
"http-body",
"http-body-util",
@@ -1433,6 +1564,12 @@ dependencies = [
"libc",
]
+[[package]]
+name = "simd-adler32"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "703d5c7ef118737c72f1af64ad2f6f8c5e1921f818cdcb97b8fe6fc69bf66214"
+
[[package]]
name = "slab"
version = "0.4.12"
diff --git a/Cargo.toml b/Cargo.toml
index f0ac2b9..3034ef5 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -25,15 +25,18 @@ tracing = "0.1"
tracing-subscriber = { version = "0.3", features = ["env-filter", "fmt", "json"] }
uuid = { version = "1", features = ["v4", "serde"] }
time = { version = "0.3", features = ["formatting"] }
-reqwest = { version = "0.12", default-features = false, features = ["json", "stream", "rustls-tls", "blocking"] }
+reqwest = { version = "0.12", default-features = false, features = ["json", "stream", "rustls-tls", "blocking", "http2"] }
base64 = "0.22"
hostname = "0.4"
once_cell = "1.20"
regex-lite = "0.1"
tokio-tungstenite = { version = "0.24", default-features = false, features = ["connect", "rustls-tls-native-roots"] }
url = "2"
+prost = "0.13"
+flate2 = "1.0"
[dev-dependencies]
tempfile = "3.14"
assert_cmd = "2"
predicates = "3"
+hex = "0.4"
diff --git a/src/config.rs b/src/config.rs
index 0d54e5f..45ffffd 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -37,6 +37,7 @@ struct FileConfig {
pub log: Option<FileLog>,
pub kimi: Option<KimiConfig>,
pub codex: Option<CodexConfig>,
+ pub cursor: Option<CursorConfig>,
}
#[derive(Deserialize, Clone)]
@@ -58,6 +59,16 @@ struct CodexConfig {
pub transport: Option<String>,
}
+#[derive(Deserialize, Clone)]
+struct CursorConfig {
+ #[serde(rename = "baseUrl")]
+ pub base_url: Option<String>,
+ #[serde(rename = "clientVersion")]
+ pub client_version: Option<String>,
+ #[serde(rename = "agentBundle")]
+ pub agent_bundle: Option<String>,
+}
+
#[derive(Deserialize, Clone)]
struct KimiConfig {
#[serde(rename = "userAgent")]
@@ -196,6 +207,12 @@ pub fn config_override_summary_lines(cfg: &LoadedConfig) -> Vec<String> {
if env.contains_key("CCP_KIMI_BASE_URL") {
out.push("kimi.baseUrl (env)".to_string());
}
+ if env.contains_key("CCP_CURSOR_BASE_URL") {
+ out.push("cursor.baseUrl (env)".to_string());
+ }
+ if env.contains_key("CCP_CURSOR_CLIENT_VERSION") {
+ out.push("cursor.clientVersion (env)".to_string());
+ }
if env.contains_key("CCP_KIMI_USER_AGENT") {
out.push("kimi.userAgent (env)".to_string());
}
@@ -427,6 +444,55 @@ pub fn codex_transport() -> CodexTransport {
CodexTransport::Http
}
+// ---------------------------------------------------------------------------
+// Cursor config
+// ---------------------------------------------------------------------------
+
+pub fn cursor_base_url() -> String {
+ let env: HashMap<_, _> = std::env::vars().collect();
+ if let Some(raw) = env.get("CCP_CURSOR_BASE_URL") {
+ return raw.clone();
+ }
+ let config_dir = paths::config_dir();
+ if let Some(file) = read_file_config(&config_dir)
+ && let Some(cursor) = file.cursor
+ && let Some(url) = cursor.base_url
+ {
+ return url;
+ }
+ "https://api2.cursor.sh".to_string()
+}
+
+pub fn cursor_client_version() -> String {
+ let env: HashMap<_, _> = std::env::vars().collect();
+ if let Some(raw) = env.get("CCP_CURSOR_CLIENT_VERSION") {
+ return raw.clone();
+ }
+ let config_dir = paths::config_dir();
+ if let Some(file) = read_file_config(&config_dir)
+ && let Some(cursor) = file.cursor
+ && let Some(version) = cursor.client_version
+ {
+ return version;
+ }
+ "0.48.5".to_string()
+}
+
+pub fn cursor_agent_bundle() -> Option<String> {
+ let env: HashMap<_, _> = std::env::vars().collect();
+ if let Some(raw) = env.get("CCP_CURSOR_AGENT_BUNDLE") {
+ return Some(raw.clone());
+ }
+ let config_dir = paths::config_dir();
+ if let Some(file) = read_file_config(&config_dir)
+ && let Some(cursor) = file.cursor
+ && let Some(bundle) = cursor.agent_bundle
+ {
+ return Some(bundle);
+ }
+ None
+}
+
#[cfg(test)]
mod tests {
use super::*;
diff --git a/src/providers/cursor/auth.rs b/src/providers/cursor/auth.rs
new file mode 100644
index 0000000..dfab337
--- /dev/null
+++ b/src/providers/cursor/auth.rs
@@ -0,0 +1,98 @@
+use std::collections::HashMap;
+
+/// Load the Cursor auth token from environment variables or auth file.
+///
+/// Resolution order:
+/// 1. `CCP_CURSOR_AUTH_TOKEN` env var
+/// 2. `CURSOR_AUTH_TOKEN` env var
+/// 3. Proxy auth file at `<config_dir>/cursor/auth.json` (accessToken field)
+/// 4. Legacy auth file at `<legacy_config_dir>/cursor/auth.json`
+pub fn load_cursor_token() -> Option<String> {
+ let env: HashMap<_, _> = std::env::vars().collect();
+ if let Some(token) = env.get("CCP_CURSOR_AUTH_TOKEN") {
+ if !token.is_empty() {
+ return Some(token.clone());
+ }
+ }
+ if let Some(token) = env.get("CURSOR_AUTH_TOKEN") {
+ if !token.is_empty() {
+ return Some(token.clone());
+ }
+ }
+
+ let path = crate::paths::provider_auth_file("cursor");
+ let legacy = crate::paths::provider_legacy_auth_file("cursor");
+
+ if path == legacy {
+ return load_token_from_file(&path);
+ }
+ load_token_from_file(&path).or_else(|| load_token_from_file(&legacy))
+}
+
+fn load_token_from_file(path: &std::path::Path) -> Option<String> {
+ let value: serde_json::Value = crate::auth::load_auth_file_value(path)?;
+ // Try accessToken first, then token
+ if let Some(token) = value.get("accessToken").and_then(|v| v.as_str()) {
+ if !token.is_empty() {
+ return Some(token.to_string());
+ }
+ }
+ if let Some(token) = value.get("token").and_then(|v| v.as_str()) {
+ if !token.is_empty() {
+ return Some(token.to_string());
+ }
+ }
+ // If the file contains a plain string token
+ if let Some(token) = value.as_str() {
+ if !token.is_empty() {
+ return Some(token.to_string());
+ }
+ }
+ None
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use once_cell::sync::Lazy;
+ use std::sync::Mutex;
+
+ static ENV_LOCK: Lazy<Mutex<()>> = Lazy::new(|| Mutex::new(()));
+
+ #[test]
+ fn auth_uses_cursor_auth_token_env() {
+ let _guard = ENV_LOCK.lock().unwrap();
+ unsafe {
+ std::env::set_var("CURSOR_AUTH_TOKEN", "tok_from_cursor");
+ std::env::remove_var("CCP_CURSOR_AUTH_TOKEN");
+ }
+ assert_eq!(load_cursor_token().as_deref(), Some("tok_from_cursor"));
+ unsafe {
+ std::env::remove_var("CURSOR_AUTH_TOKEN");
+ }
+ }
+
+ #[test]
+ fn auth_prioritizes_ccp_env_over_cursor_env() {
+ let _guard = ENV_LOCK.lock().unwrap();
+ unsafe {
+ std::env::set_var("CCP_CURSOR_AUTH_TOKEN", "tok_ccp");
+ std::env::set_var("CURSOR_AUTH_TOKEN", "tok_cursor");
+ }
+ assert_eq!(load_cursor_token().as_deref(), Some("tok_ccp"));
+ unsafe {
+ std::env::remove_var("CCP_CURSOR_AUTH_TOKEN");
+ std::env::remove_var("CURSOR_AUTH_TOKEN");
+ }
+ }
+
+ #[test]
+ fn auth_returns_none_when_not_set() {
+ let _guard = ENV_LOCK.lock().unwrap();
+ unsafe {
+ std::env::remove_var("CCP_CURSOR_AUTH_TOKEN");
+ std::env::remove_var("CURSOR_AUTH_TOKEN");
+ }
+ assert!(load_cursor_token().is_none());
+ }
+}
diff --git a/src/providers/cursor/client.rs b/src/providers/cursor/client.rs
new file mode 100644
index 0000000..bc0c2cd
--- /dev/null
+++ b/src/providers/cursor/client.rs
@@ -0,0 +1,292 @@
+use prost::Message;
+
+use crate::config;
+use crate::providers::cursor::connect::{
+ ConnectFrame, ConnectFrameDecoder, FLAG_END, FLAG_GZIP, encode_connect_frame,
+ parse_connect_error,
+};
+use crate::providers::cursor::model::CursorModelResolution;
+use crate::providers::cursor::proto::{self, AgentClientMessage, RunRequest};
+use crate::providers::cursor::request::CursorSelectedImage;
+
+/// Upstream response from the Cursor API.
+///
+/// Contains the raw response bytes (or body bytes for streaming) and the
+/// HTTP status.
+pub struct CursorUpstreamResponse {
+ pub status: u16,
+ pub body: Vec<u8>,
+ pub error_detail: Option<String>,
+}
+
+impl CursorUpstreamResponse {
+ pub fn is_success(&self) -> bool {
+ self.status >= 200 && self.status < 300
+ }
+}
+
+/// HTTP/2 client for the Cursor AgentService/Run endpoint.
+pub struct CursorHttpClient {
+ client: reqwest::Client,
+ base_url: String,
+}
+
+impl Default for CursorHttpClient {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl CursorHttpClient {
+ pub fn new() -> Self {
+ // Use HTTP/2 prior knowledge for cleartext URLs (mock testing) and
+ // standard TLS for https URLs.
+ let base_url = config::cursor_base_url();
+ let is_cleartext = base_url.starts_with("http://");
+
+ let mut builder = reqwest::Client::builder()
+ .http2_keep_alive_timeout(std::time::Duration::from_secs(30))
+ .http2_keep_alive_while_idle(true);
+
+ if is_cleartext {
+ builder = builder.http2_prior_knowledge();
+ }
+
+ let client = builder.build().expect("CursorHttpClient: reqwest client");
+
+ Self { client, base_url }
+ }
+
+ /// Run the Cursor agent with the given prompt and token.
+ ///
+ /// Builds the prost RunRequest, encodes it in a Connect frame, and
+ /// sends it via HTTP/2 POST.
+ pub async fn run_agent(
+ &self,
+ token: &str,
+ prompt: &str,
+ model: &str,
+ images: &[CursorSelectedImage],
+ ) -> Result<CursorUpstreamResponse, CursorError> {
+ let resolved = super::model::resolve_cursor_model(model)
+ .map_err(|e| CursorError::internal(format!("model resolution: {e}")))?;
+
+ let request_id = uuid::Uuid::new_v4().to_string();
+
+ // Build the prost RunRequest
+ let run_request = build_run_request(prompt, &resolved, images, &request_id);
+
+ let msg = AgentClientMessage {
+ run_request: Some(run_request),
+ client_heartbeat: None,
+ };
+
+ let mut payload = Vec::new();
+ msg.encode(&mut payload)
+ .map_err(|e| CursorError::internal(format!("prost encode: {e}")))?;
+
+ let body = encode_connect_frame(&payload, 0);
+
+ let url = format!(
+ "{}/agent.v1.AgentService/Run",
+ self.base_url.trim_end_matches('/')
+ );
+
+ let client_version = config::cursor_client_version();
+
+ let resp = self
+ .client
+ .post(&url)
+ .bearer_auth(token)
+ .header("content-type", "application/connect+proto")
+ .header("connect-protocol-version", "1")
+ .header("connect-accept-encoding", "gzip,br")
+ .header("x-cursor-client-type", "cli")
+ .header("x-cursor-client-version", &client_version)
+ .header("x-ghost-mode", "true")
+ .header("x-request-id", &request_id)
+ .header("x-original-request-id", &request_id)
+ .header("x-cursor-streaming", "true")
+ .header("te", "trailers")
+ .body(body)
+ .send()
+ .await
+ .map_err(|e| CursorError::from_reqwest(e))?;
+
+ let status = resp.status().as_u16();
+ let headers = resp.headers().clone();
+ let error_detail = resp
+ .headers()
+ .get("grpc-message")
+ .and_then(|v| v.to_str().ok())
+ .map(|s| s.to_string());
+
+ let body_bytes = resp
+ .bytes()
+ .await
+ .map_err(|e| CursorError::internal(format!("read body: {e}")))?;
+
+ if status >= 400 {
+ // Try to extract Connect error from body
+ let detail = parse_error_body(&body_bytes, &headers);
+ return Err(CursorError::new(status, "Cursor upstream error", detail));
+ }
+
+ Ok(CursorUpstreamResponse {
+ status,
+ body: body_bytes.to_vec(),
+ error_detail,
+ })
+ }
+}
+
+fn build_run_request(
+ prompt: &str,
+ resolved: &CursorModelResolution,
+ images: &[CursorSelectedImage],
+ request_id: &str,
+) -> RunRequest {
+ let selected_images: Vec<proto::SelectedImage> = images
+ .iter()
+ .map(|img| proto::SelectedImage {
+ data: img.data.clone(),
+ uuid: img.uuid.clone(),
+ path: img.path.clone(),
+ mime_type: img.mime_type.clone(),
+ })
+ .collect();
+
+ RunRequest {
+ conversation_state: Some(proto::ConversationState {
+ messages: Vec::new(),
+ }),
+ action: Some(proto::Action {
+ user_message_action: Some(proto::UserMessageAction {
+ user_message: Some(proto::UserMessage {
+ text: prompt.to_string(),
+ message_id: request_id.to_string(),
+ selected_context: if selected_images.is_empty() {
+ None
+ } else {
+ Some(proto::SelectedContext { selected_images })
+ },
+ mode: resolved.mode.as_str().to_string(),
+ }),
+ }),
+ }),
+ mcp_tools: None,
+ conversation_id: String::new(),
+ requested_model: Some(proto::CursorModel {
+ model_id: resolved.model_id.clone(),
+ parameters: Vec::new(),
+ }),
+ exclude_workspace_context: false,
+ selected_subagent_models: vec![],
+ conversation_group_id: String::new(),
+ client_supports_inline_images: true,
+ }
+}
+
+fn parse_error_body(body_bytes: &[u8], _headers: &reqwest::header::HeaderMap) -> Option<String> {
+ if body_bytes.len() < 5 {
+ return None;
+ }
+ // Try to parse as Connect end frame with JSON error
+ if body_bytes.len() >= 5 {
+ let flags = body_bytes[0];
+ let len = u32::from_be_bytes([body_bytes[1], body_bytes[2], body_bytes[3], body_bytes[4]])
+ as usize;
+ if flags & FLAG_END != 0 && body_bytes.len() >= 5 + len {
+ let payload = &body_bytes[5..5 + len];
+ let err = parse_connect_error(payload);
+ if err.is_some() {
+ return err.map(|e| e.detail);
+ }
+ }
+ }
+
+ // Try plain text error
+ if let Ok(text) = String::from_utf8(body_bytes.to_vec()) {
+ if !text.is_empty() {
+ return Some(text);
+ }
+ }
+ None
+}
+
+/// Decode upstream response bytes into Connect frames containing
+/// AgentServerMessage values.
+pub fn decode_upstream_frames(body: &[u8]) -> Result<Vec<ConnectFrame>, CursorError> {
+ let mut decoder = ConnectFrameDecoder::new();
+ let frames = decoder
+ .push(body)
+ .map_err(|e| CursorError::internal(format!("frame decode: {e}")))?;
+ Ok(frames)
+}
+
+/// Decode a single Connect frame payload into an AgentServerMessage.
+/// Handles gzip decompression if the FLAG_GZIP bit is set.
+pub fn decode_frame_payload(
+ frame: &ConnectFrame,
+) -> Result<proto::AgentServerMessage, CursorError> {
+ let payload = if frame.flags & FLAG_GZIP != 0 {
+ let decompressed = super::connect::decode_gzip_frame(&frame.payload)
+ .map_err(|e| CursorError::internal(format!("gzip decompress: {e}")))?;
+ decompressed
+ } else {
+ frame.payload.to_vec()
+ };
+
+ proto::AgentServerMessage::decode(&payload[..])
+ .map_err(|e| CursorError::internal(format!("prost decode: {e}")))
+}
+
+// ---------------------------------------------------------------------------
+// Error type
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone)]
+pub struct CursorError {
+ pub status: u16,
+ pub message: String,
+ pub detail: Option<String>,
+ pub retry_after: Option<String>,
+}
+
+impl CursorError {
+ pub fn new(status: u16, message: impl Into<String>, detail: Option<String>) -> Self {
+ Self {
+ status,
+ message: message.into(),
+ detail,
+ retry_after: None,
+ }
+ }
+
+ pub fn internal(message: impl Into<String>) -> Self {
+ Self {
+ status: 502,
+ message: message.into(),
+ detail: None,
+ retry_after: None,
+ }
+ }
+
+ pub fn from_reqwest(e: reqwest::Error) -> Self {
+ let status = e.status().map(|s| s.as_u16()).unwrap_or(502);
+ Self {
+ status,
+ message: e.to_string(),
+ detail: None,
+ retry_after: None,
+ }
+ }
+}
+
+impl std::fmt::Display for CursorError {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ write!(f, "Cursor error {}: {}", self.status, self.message)
+ }
+}
+
+impl std::error::Error for CursorError {}
diff --git a/src/providers/cursor/connect.rs b/src/providers/cursor/connect.rs
new file mode 100644
index 0000000..99b037d
--- /dev/null
+++ b/src/providers/cursor/connect.rs
@@ -0,0 +1,373 @@
+use bytes::{Bytes, BytesMut};
+
+// Connect frame flags
+pub const FLAG_GZIP: u8 = 0x01;
+pub const FLAG_END: u8 = 0x02;
+
+/// A single Connect frame with flags and payload.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ConnectFrame {
+ pub flags: u8,
+ pub payload: Bytes,
+}
+
+/// Encode a payload into a Connect frame: 1 byte flags, 4 byte big-endian
+/// payload length, then the payload bytes.
+pub fn encode_connect_frame(payload: impl AsRef<[u8]>, flags: u8) -> Bytes {
+ let payload = payload.as_ref();
+ let mut out = BytesMut::with_capacity(5 + payload.len());
+ out.extend_from_slice(&[flags]);
+ out.extend_from_slice(&(payload.len() as u32).to_be_bytes());
+ out.extend_from_slice(payload);
+ out.freeze()
+}
+
+/// Streaming decoder for Connect frames from a byte source.
+///
+/// Handles split chunks, multiple frames in a single chunk, and malformed
+/// (oversized) lengths. Does NOT handle gzip decompression inline -- the
+/// caller checks `FLAG_GZIP` and decompresses if desired.
+///
+/// End frames (FLAG_END set) with an empty or JSON payload are returned
+/// as ConnectFrames. The caller inspects the payload to determine whether
+/// it conveys a Connect error.
+#[derive(Default)]
+pub struct ConnectFrameDecoder {
+ buffer: BytesMut,
+}
+
+impl ConnectFrameDecoder {
+ pub fn new() -> Self {
+ Self::default()
+ }
+
+ /// Feed bytes into the decoder. Returns all complete frames found.
+ ///
+ /// Returns an error if a frame header advertises a length that exceeds
+ /// `max_frame_payload` (default 64 MiB).
+ pub fn push(&mut self, chunk: impl AsRef<[u8]>) -> Result<Vec<ConnectFrame>, ConnectError> {
+ self.buffer.extend_from_slice(chunk.as_ref());
+ self.drain(64 * 1024 * 1024) // 64 MiB max payload
+ }
+
+ /// Same as `push` but with an explicit `max_payload` limit for testing.
+ pub fn push_with_limit(
+ &mut self,
+ chunk: impl AsRef<[u8]>,
+ max_payload: usize,
+ ) -> Result<Vec<ConnectFrame>, ConnectError> {
+ self.buffer.extend_from_slice(chunk.as_ref());
+ self.drain(max_payload)
+ }
+
+ fn drain(&mut self, max_payload: usize) -> Result<Vec<ConnectFrame>, ConnectError> {
+ let mut out = Vec::new();
+ loop {
+ if self.buffer.len() < 5 {
+ break;
+ }
+ let len = u32::from_be_bytes([
+ self.buffer[1],
+ self.buffer[2],
+ self.buffer[3],
+ self.buffer[4],
+ ]) as usize;
+
+ if len > max_payload {
+ return Err(ConnectError::PayloadTooLarge {
+ length: len,
+ max: max_payload,
+ });
+ }
+
+ if self.buffer.len() < 5 + len {
+ break;
+ }
+
+ let mut raw = self.buffer.split_to(5 + len);
+ out.push(ConnectFrame {
+ flags: raw[0],
+ payload: raw.split_off(5).freeze(),
+ });
+ }
+ Ok(out)
+ }
+
+ /// Return the number of buffered bytes (incomplete frame data).
+ pub fn buffered(&self) -> usize {
+ self.buffer.len()
+ }
+}
+
+/// Decode gzipped payload bytes. The caller decides when to call this based
+/// on frame flags & FLAG_GZIP.
+pub fn decode_gzip_frame(payload: &[u8]) -> Result<Vec<u8>, std::io::Error> {
+ use std::io::Read;
+ let mut decoder = flate2::read::GzDecoder::new(payload);
+ let mut out = Vec::new();
+ decoder.read_to_end(&mut out)?;
+ Ok(out)
+}
+
+/// Parse a Connect end-frame JSON error payload into a structured error.
+///
+/// Returns `None` if the payload is empty or not valid Connect error JSON.
+pub fn parse_connect_error(payload: &[u8]) -> Option<ConnectEndError> {
+ if payload.is_empty() {
+ return None;
+ }
+ let parsed: serde_json::Value = serde_json::from_slice(payload).ok()?;
+ let error = parsed.get("error")?;
+ let code = error.get("code")?.as_str()?;
+ let message = error.get("message")?.as_str().unwrap_or("Connect error");
+ let status = match code {
+ "resource_exhausted" => 429,
+ _ => 502,
+ };
+ Some(ConnectEndError {
+ code: code.to_string(),
+ message: message.to_string(),
+ detail: parsed.to_string(),
+ status,
+ })
+}
+
+#[derive(Debug, Clone)]
+pub struct ConnectEndError {
+ pub code: String,
+ pub message: String,
+ pub detail: String,
+ pub status: u16,
+}
+
+impl std::fmt::Display for ConnectEndError {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ write!(
+ f,
+ "Connect error {}: {} ({})",
+ self.status, self.message, self.code
+ )
+ }
+}
+
+impl std::error::Error for ConnectEndError {}
+
+#[derive(Debug, Clone)]
+pub enum ConnectError {
+ PayloadTooLarge { length: usize, max: usize },
+}
+
+impl std::fmt::Display for ConnectError {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ match self {
+ ConnectError::PayloadTooLarge { length, max } => {
+ write!(f, "Connect frame payload {length} exceeds max {max}")
+ }
+ }
+ }
+}
+
+impl std::error::Error for ConnectError {}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn encode_roundtrip() {
+ let frame = encode_connect_frame(b"hello", 0);
+ let mut decoder = ConnectFrameDecoder::new();
+ let frames = decoder.push(&frame).unwrap();
+ assert_eq!(frames.len(), 1);
+ assert_eq!(frames[0].flags, 0);
+ assert_eq!(&frames[0].payload[..], b"hello");
+ }
+
+ #[test]
+ fn encode_with_gzip_flag() {
+ let frame = encode_connect_frame(b"gzip-data", FLAG_GZIP);
+ let mut decoder = ConnectFrameDecoder::new();
+ let frames = decoder.push(&frame).unwrap();
+ assert_eq!(frames.len(), 1);
+ assert_eq!(frames[0].flags, FLAG_GZIP);
+ }
+
+ #[test]
+ fn encode_with_end_flag() {
+ let frame = encode_connect_frame(b"", FLAG_END);
+ let mut decoder = ConnectFrameDecoder::new();
+ let frames = decoder.push(&frame).unwrap();
+ assert_eq!(frames.len(), 1);
+ assert_eq!(frames[0].flags, FLAG_END);
+ assert!(frames[0].payload.is_empty());
+ }
+
+ #[test]
+ fn encode_with_gzip_and_end_flags() {
+ let payload = b"end-data";
+ let frame = encode_connect_frame(payload, FLAG_GZIP | FLAG_END);
+ let mut decoder = ConnectFrameDecoder::new();
+ let frames = decoder.push(&frame).unwrap();
+ assert_eq!(frames.len(), 1);
+ assert_eq!(frames[0].flags, FLAG_GZIP | FLAG_END);
+ assert_eq!(&frames[0].payload[..], payload);
+ }
+
+ #[test]
+ fn multiple_frames_in_single_chunk() {
+ let f1 = encode_connect_frame(b"first", 0);
+ let f2 = encode_connect_frame(b"second", 0);
+ let mut combined = BytesMut::new();
+ combined.extend_from_slice(&f1);
+ combined.extend_from_slice(&f2);
+
+ let mut decoder = ConnectFrameDecoder::new();
+ let frames = decoder.push(combined).unwrap();
+ assert_eq!(frames.len(), 2);
+ assert_eq!(&frames[0].payload[..], b"first");
+ assert_eq!(&frames[1].payload[..], b"second");
+ }
+
+ #[test]
+ fn split_chunks_are_assembled() {
+ let frame = encode_connect_frame(b"split-test", 0);
+ let (a, b) = frame.split_at(3);
+
+ let mut decoder = ConnectFrameDecoder::new();
+ let frames = decoder.push(a).unwrap();
+ assert!(frames.is_empty());
+
+ let frames = decoder.push(b).unwrap();
+ assert_eq!(frames.len(), 1);
+ assert_eq!(&frames[0].payload[..], b"split-test");
+ }
+
+ #[test]
+ fn split_at_header_boundary() {
+ let frame = encode_connect_frame(b"split-at-5", 0);
+ // Split after the flags byte but before the length bytes are complete
+ let (a, b) = frame.split_at(1);
+
+ let mut decoder = ConnectFrameDecoder::new();
+ let frames = decoder.push(a).unwrap();
+ assert!(frames.is_empty());
+
+ let frames = decoder.push(b).unwrap();
+ assert_eq!(frames.len(), 1);
+ assert_eq!(&frames[0].payload[..], b"split-at-5");
+ }
+
+ #[test]
+ fn oversized_length_is_rejected() {
+ let mut decoder = ConnectFrameDecoder::new();
+ // Encode a frame with 1M payload (will exceed our 10-byte max)
+ let oversized = encode_connect_frame(vec![0u8; 100], 0);
+ let result = decoder.push_with_limit(&oversized, 10);
+ assert!(result.is_err());
+ match result.unwrap_err() {
+ ConnectError::PayloadTooLarge { length, max } => {
+ assert_eq!(length, 100);
+ assert_eq!(max, 10);
+ }
+ }
+ }
+
+ #[test]
+ fn empty_chunk_produces_no_frames() {
+ let mut decoder = ConnectFrameDecoder::new();
+ let frames = decoder.push(b"").unwrap();
+ assert!(frames.is_empty());
+ }
+
+ #[test]
+ fn buf_returns_buffered_bytes() {
+ let mut decoder = ConnectFrameDecoder::new();
+ // Push part of a frame header
+ decoder.push(b"\x00\x00").unwrap();
+ assert_eq!(decoder.buffered(), 2);
+ }
+
+ #[test]
+ fn clean_end_frame_empty_payload() {
+ let frame = encode_connect_frame(b"", FLAG_END);
+ let mut decoder = ConnectFrameDecoder::new();
+ let frames = decoder.push(frame).unwrap();
+ assert_eq!(frames.len(), 1);
+ assert_eq!(frames[0].flags, FLAG_END);
+ assert!(frames[0].payload.is_empty());
+ // Parse error from empty payload
+ assert!(parse_connect_error(&frames[0].payload).is_none());
+ }
+
+ #[test]
+ fn connect_json_error_parsing() {
+ let json_err = serde_json::json!({
+ "error": {
+ "code": "resource_exhausted",
+ "message": "quota exceeded",
+ "details": []
+ }
+ });
+ let payload = serde_json::to_vec(&json_err).unwrap();
+ let frame = encode_connect_frame(&payload, FLAG_END);
+ let mut decoder = ConnectFrameDecoder::new();
+ let frames = decoder.push(frame).unwrap();
+ assert_eq!(frames.len(), 1);
+
+ let err = parse_connect_error(&frames[0].payload).unwrap();
+ assert_eq!(err.code, "resource_exhausted");
+ assert_eq!(err.status, 429);
+ assert_eq!(err.message, "quota exceeded");
+ }
+
+ #[test]
+ fn connect_json_unavailable_error() {
+ let json_err = serde_json::json!({
+ "error": {
+ "code": "unavailable",
+ "message": "service unavailable"
+ }
+ });
+ let payload = serde_json::to_vec(&json_err).unwrap();
+ let err = parse_connect_error(&payload).unwrap();
+ assert_eq!(err.code, "unavailable");
+ assert_eq!(err.status, 502);
+ }
+
+ #[test]
+ fn frame_fixture_matches_reference_layout() {
+ // Connect frame: flags=0x00, length=3 (0x00000003), payload="abc"
+ // Wire format: [0x00, 0x00, 0x00, 0x00, 0x03, 0x61, 0x62, 0x63]
+ let frame = encode_connect_frame(b"abc", 0);
+ assert_eq!(hex::encode(frame), "0000000003616263");
+ }
+
+ #[test]
+ fn frame_fixture_with_flags() {
+ // flags=0x01, length=3
+ let frame = encode_connect_frame(b"xyz", 0x01);
+ assert_eq!(hex::encode(frame), "010000000378797a");
+ }
+
+ #[test]
+ fn gzip_frame_decompress() {
+ let payload = b"hello gzip";
+ let mut compressed = Vec::new();
+ {
+ use std::io::Write;
+ let mut encoder =
+ flate2::write::GzEncoder::new(&mut compressed, flate2::Compression::fast());
+ encoder.write_all(payload).unwrap();
+ encoder.finish().unwrap();
+ }
+
+ let frame = encode_connect_frame(&compressed, FLAG_GZIP);
+ let mut decoder = ConnectFrameDecoder::new();
+ let frames = decoder.push(frame).unwrap();
+ assert_eq!(frames.len(), 1);
+ assert_eq!(frames[0].flags, FLAG_GZIP);
+
+ let decompressed = decode_gzip_frame(&frames[0].payload).unwrap();
+ assert_eq!(decompressed, b"hello gzip");
+ }
+}
diff --git a/src/providers/cursor/mod.rs b/src/providers/cursor/mod.rs
new file mode 100644
index 0000000..ceeed69
--- /dev/null
+++ b/src/providers/cursor/mod.rs
@@ -0,0 +1,229 @@
+pub mod auth;
+pub mod client;
+pub mod connect;
+pub mod model;
+pub mod proto;
+pub mod request;
+pub mod response;
+pub mod sse;
+
+use async_trait::async_trait;
+use axum::Json;
+use axum::response::{IntoResponse, Response};
+use http::StatusCode;
+
+use crate::anthropic::error::json_error;
+use crate::anthropic::schema::{CountTokensResponse, MessagesRequest};
+use crate::provider::{CliHandlers, Provider, RequestContext};
+use crate::providers::cursor::auth::load_cursor_token;
+use crate::providers::cursor::client::CursorHttpClient;
+use crate::providers::cursor::model::resolve_cursor_model;
+use crate::providers::cursor::request::render_cursor_prompt;
+use crate::providers::cursor::response::decode_cursor_upstream;
+
+// ---------------------------------------------------------------------------
+// Provider
+// ---------------------------------------------------------------------------
+
+pub struct CursorProvider;
+
+impl Default for CursorProvider {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl CursorProvider {
+ pub fn new() -> Self {
+ Self
+ }
+}
+
+#[async_trait]
+impl Provider for CursorProvider {
+ fn name(&self) -> &'static str {
+ "cursor"
+ }
+
+ fn supported_models(&self) -> Vec<String> {
+ model::cursor_supported_models()
+ }
+
+ fn cli(&self) -> &'static dyn CliHandlers {
+ &CURSOR_CLI
+ }
+
+ async fn handle_messages(&self, body: MessagesRequest, _ctx: RequestContext) -> Response {
+ let message_id = format!("msg_{}", uuid::Uuid::new_v4().to_string().replace('-', ""));
+ let want_stream = body.stream;
+ let model = body.model.as_deref().unwrap_or("cursor");
+
+ let resolved = resolve_cursor_model(model);
+ if let Err(e) = resolved {
+ return json_error(
+ StatusCode::BAD_REQUEST,
+ "invalid_request_error",
+ format!("Model \"{model}\" is not supported: {e}"),
+ );
+ }
+
+ let token = match load_cursor_token() {
+ Some(t) => t,
+ None => {
+ return json_error(
+ StatusCode::UNAUTHORIZED,
+ "authentication_error",
+ "Cursor auth token not found. Set CCP_CURSOR_AUTH_TOKEN or CURSOR_AUTH_TOKEN",
+ );
+ }
+ };
+
+ let prompt = render_cursor_prompt(&body);
+ let images = request::cursor_selected_images(&body);
+
+ let client = CursorHttpClient::new();
+ let upstream = match client.run_agent(&token, &prompt, &model, &images).await {
+ Ok(r) => r,
+ Err(e) => {
+ return map_cursor_error_to_response(&e);
+ }
+ };
+
+ if want_stream {
+ let sse_bytes = sse::frame_cursor_stream(&upstream, &message_id, model);
+ let headers = [
+ (http::header::CONTENT_TYPE, "text/event-stream"),
+ (http::header::CACHE_CONTROL, "no-cache"),
+ (http::header::CONNECTION, "keep-alive"),
+ ];
+ (headers, sse_bytes).into_response()
+ } else {
+ match decode_cursor_upstream(&upstream, &message_id, model) {
+ Ok(json) => (StatusCode::OK, Json(json)).into_response(),
+ Err(e) => json_error(
+ StatusCode::BAD_GATEWAY,
+ "api_error",
+ format!("Response decoding error: {e}"),
+ ),
+ }
+ }
+ }
+
+ async fn handle_count_tokens(&self, body: MessagesRequest, _ctx: RequestContext) -> Response {
+ let prompt = render_cursor_prompt(&body);
+ let tokens = (prompt.len() / 4) as u64; // rough estimate
+ (
+ StatusCode::OK,
+ Json(CountTokensResponse {
+ input_tokens: tokens,
+ }),
+ )
+ .into_response()
+ }
+}
+
+// ---------------------------------------------------------------------------
+// Error mapping
+// ---------------------------------------------------------------------------
+
+fn map_cursor_error_to_response(err: &client::CursorError) -> Response {
+ match err.status {
+ 401 | 403 => json_error(
+ StatusCode::UNAUTHORIZED,
+ "authentication_error",
+ err.detail.as_deref().unwrap_or("Authentication failed"),
+ ),
+ 429 => {
+ let retry_after = err.retry_after.as_deref().unwrap_or("5");
+ let resp = json_error(
+ StatusCode::TOO_MANY_REQUESTS,
+ "rate_limit_error",
+ &err.message,
+ );
+ let headers = [(http::header::RETRY_AFTER, retry_after)];
+ (headers, resp).into_response()
+ }
+ _ => json_error(
+ StatusCode::BAD_GATEWAY,
+ "api_error",
+ err.detail.as_deref().unwrap_or("Upstream error"),
+ ),
+ }
+}
+
+// ---------------------------------------------------------------------------
+// CLI
+// ---------------------------------------------------------------------------
+
+pub(crate) struct CursorCli;
+
+impl CliHandlers for CursorCli {
+ fn login(&self) -> Result<(), anyhow::Error> {
+ anyhow::bail!(
+ "cursor: browser login not supported; use env CCP_CURSOR_AUTH_TOKEN or CURSOR_AUTH_TOKEN"
+ );
+ }
+
+ fn device(&self) -> Result<(), anyhow::Error> {
+ anyhow::bail!("cursor: device login not yet implemented");
+ }
+
+ fn status(&self) -> Result<(), anyhow::Error> {
+ match load_cursor_token() {
+ Some(_) => {
+ println!("Cursor auth token: found");
+ Ok(())
+ }
+ None => {
+ anyhow::bail!("Not authenticated");
+ }
+ }
+ }
+
+ fn logout(&self) -> Result<(), anyhow::Error> {
+ println!(
+ "cursor: env-based auth has no persistent file to clear; unset CCP_CURSOR_AUTH_TOKEN or CURSOR_AUTH_TOKEN"
+ );
+ Ok(())
+ }
+}
+
+pub(crate) static CURSOR_CLI: CursorCli = CursorCli;
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn supported_models_includes_legacy_and_agent() {
+ let provider = CursorProvider::new();
+ let models = provider.supported_models();
+ assert!(models.contains(&"cursor".to_string()));
+ assert!(models.contains(&"cursor-agent".to_string()));
+ assert!(models.contains(&"cursor-plan".to_string()));
+ assert!(models.contains(&"cursor-ask".to_string()));
+ }
+
+ #[test]
+ fn cursor_cli_status_unauthenticated() {
+ // Unset env vars for the test scope
+ unsafe {
+ std::env::remove_var("CCP_CURSOR_AUTH_TOKEN");
+ std::env::remove_var("CURSOR_AUTH_TOKEN");
+ }
+ let result = CURSOR_CLI.status();
+ assert!(result.is_err());
+ assert!(
+ result
+ .unwrap_err()
+ .to_string()
+ .contains("Not authenticated")
+ );
+ }
+
+ #[test]
+ fn cursor_cli_logout_does_not_error() {
+ let result = CURSOR_CLI.logout();
+ assert!(result.is_ok());
+ }
+}
diff --git a/src/providers/cursor/model.rs b/src/providers/cursor/model.rs
new file mode 100644
index 0000000..7f165ea
--- /dev/null
+++ b/src/providers/cursor/model.rs
@@ -0,0 +1,189 @@
+/// Cursor model catalog -- resolves incoming model names to Cursor model IDs.
+///
+/// Resolution rules mirror the TypeScript reference:
+/// - `cursor:`, `cursor-plan:`, `cursor-ask:` prefixes are stripped and mapped
+/// to the corresponding agent mode.
+/// - Legacy names like `cursor`, `cursor-agent`, `cursor-composer`,
+/// `cursor-composer-fast`, `cursor-plan`, `cursor-ask`, `composer-2.5`,
+/// `composer-2.5-fast` are recognized.
+/// - `cursor-agent:` is also supported for agent mode routing.
+
+pub const CURSOR_LEGACY_MODELS: &[&str] = &[
+ "cursor",
+ "cursor-agent",
+ "cursor-composer",
+ "cursor-composer-fast",
+ "cursor-plan",
+ "cursor-ask",
+ "composer-2.5",
+ "composer-2.5-fast",
+];
+
+/// Agent mode derived from model prefix or name.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum CursorAgentMode {
+ Agent,
+ Plan,
+ Ask,
+}
+
+impl CursorAgentMode {
+ pub fn as_str(&self) -> &'static str {
+ match self {
+ CursorAgentMode::Agent => "AGENT_MODE_AGENT",
+ CursorAgentMode::Plan => "AGENT_MODE_PLAN",
+ CursorAgentMode::Ask => "AGENT_MODE_ASK",
+ }
+ }
+}
+
+/// Resolve a model string into a (model_id, mode) pair.
+///
+/// Returns an error if the model is not recognized.
+pub fn resolve_cursor_model(model: &str) -> Result<CursorModelResolution, String> {
+ let model = model.trim();
+
+ // Strip known prefixes
+ if let Some(rest) = model.strip_prefix("cursor-agent:") {
+ return Ok(CursorModelResolution {
+ model_id: rest.to_string(),
+ mode: CursorAgentMode::Agent,
+ });
+ }
+ if let Some(rest) = model.strip_prefix("cursor-plan:") {
+ return Ok(CursorModelResolution {
+ model_id: rest.to_string(),
+ mode: CursorAgentMode::Plan,
+ });
+ }
+ if let Some(rest) = model.strip_prefix("cursor-ask:") {
+ return Ok(CursorModelResolution {
+ model_id: rest.to_string(),
+ mode: CursorAgentMode::Ask,
+ });
+ }
+ if let Some(rest) = model.strip_prefix("cursor:") {
+ return Ok(CursorModelResolution {
+ model_id: rest.to_string(),
+ mode: CursorAgentMode::Agent,
+ });
+ }
+
+ // Legacy exact names
+ match model {
+ "cursor" | "cursor-agent" | "cursor-composer" | "cursor-composer-fast" => {
+ Ok(CursorModelResolution {
+ model_id: model.to_string(),
+ mode: CursorAgentMode::Agent,
+ })
+ }
+ "cursor-plan" | "composer-2.5" => Ok(CursorModelResolution {
+ model_id: model.to_string(),
+ mode: CursorAgentMode::Plan,
+ }),
+ "cursor-ask" | "composer-2.5-fast" => Ok(CursorModelResolution {
+ model_id: model.to_string(),
+ mode: CursorAgentMode::Ask,
+ }),
+ _ => Err(format!(
+ "unknown cursor model: {model}. Supported: cursor:<id>, cursor-plan:<id>, cursor-ask:<id>, cursor-agent"
+ )),
+ }
+}
+
+#[derive(Debug, Clone)]
+pub struct CursorModelResolution {
+ pub model_id: String,
+ pub mode: CursorAgentMode,
+}
+
+/// Build the list of supported Cursor model names.
+pub fn cursor_supported_models() -> Vec<String> {
+ let mut out: Vec<String> = CURSOR_LEGACY_MODELS
+ .iter()
+ .map(|s| (*s).to_string())
+ .collect();
+ out.sort_unstable();
+ out
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn resolve_legacy_cursor() {
+ let r = resolve_cursor_model("cursor").unwrap();
+ assert_eq!(r.model_id, "cursor");
+ assert_eq!(r.mode, CursorAgentMode::Agent);
+ }
+
+ #[test]
+ fn resolve_legacy_cursor_agent() {
+ let r = resolve_cursor_model("cursor-agent").unwrap();
+ assert_eq!(r.mode, CursorAgentMode::Agent);
+ }
+
+ #[test]
+ fn resolve_legacy_cursor_plan() {
+ let r = resolve_cursor_model("cursor-plan").unwrap();
+ assert_eq!(r.mode, CursorAgentMode::Plan);
+ }
+
+ #[test]
+ fn resolve_legacy_cursor_ask() {
+ let r = resolve_cursor_model("cursor-ask").unwrap();
+ assert_eq!(r.mode, CursorAgentMode::Ask);
+ }
+
+ #[test]
+ fn resolve_prefixed_cursor() {
+ let r = resolve_cursor_model("cursor:gpt-5.5").unwrap();
+ assert_eq!(r.model_id, "gpt-5.5");
+ assert_eq!(r.mode, CursorAgentMode::Agent);
+ }
+
+ #[test]
+ fn resolve_prefixed_cursor_plan() {
+ let r = resolve_cursor_model("cursor-plan:gpt-5.5").unwrap();
+ assert_eq!(r.model_id, "gpt-5.5");
+ assert_eq!(r.mode, CursorAgentMode::Plan);
+ }
+
+ #[test]
+ fn resolve_prefixed_cursor_ask() {
+ let r = resolve_cursor_model("cursor-ask:gpt-5.5").unwrap();
+ assert_eq!(r.model_id, "gpt-5.5");
+ assert_eq!(r.mode, CursorAgentMode::Ask);
+ }
+
+ #[test]
+ fn resolve_prefixed_cursor_agent() {
+ let r = resolve_cursor_model("cursor-agent:gpt-5.5").unwrap();
+ assert_eq!(r.model_id, "gpt-5.5");
+ assert_eq!(r.mode, CursorAgentMode::Agent);
+ }
+
+ #[test]
+ fn resolve_unknown_model_errors() {
+ let r = resolve_cursor_model("unknown-model");
+ assert!(r.is_err());
+ }
+
+ #[test]
+ fn resolve_composer_models() {
+ let r = resolve_cursor_model("composer-2.5").unwrap();
+ assert_eq!(r.mode, CursorAgentMode::Plan);
+
+ let r = resolve_cursor_model("composer-2.5-fast").unwrap();
+ assert_eq!(r.mode, CursorAgentMode::Ask);
+ }
+
+ #[test]
+ fn supported_models_includes_all_legacy() {
+ let models = cursor_supported_models();
+ for m in CURSOR_LEGACY_MODELS {
+ assert!(models.contains(&m.to_string()), "missing {m}");
+ }
+ }
+}
diff --git a/src/providers/cursor/proto.rs b/src/providers/cursor/proto.rs
new file mode 100644
index 0000000..2a93f14
--- /dev/null
+++ b/src/providers/cursor/proto.rs
@@ -0,0 +1,186 @@
+use prost::Message;
+
+// ---------------------------------------------------------------------------
+// Agent client message (request)
+// ---------------------------------------------------------------------------
+
+#[derive(Clone, PartialEq, Message)]
+pub struct AgentClientMessage {
+ #[prost(message, optional, tag = "1")]
+ pub run_request: Option<RunRequest>,
+ #[prost(message, optional, tag = "2")]
+ pub client_heartbeat: Option<ClientHeartbeat>,
+}
+
+#[derive(Clone, PartialEq, Message)]
+pub struct RunRequest {
+ #[prost(message, optional, tag = "1")]
+ pub conversation_state: Option<ConversationState>,
+ #[prost(message, optional, tag = "2")]
+ pub action: Option<Action>,
+ #[prost(message, optional, tag = "6")]
+ pub mcp_tools: Option<McpTools>,
+ #[prost(string, tag = "7")]
+ pub conversation_id: String,
+ #[prost(message, optional, tag = "8")]
+ pub requested_model: Option<CursorModel>,
+ #[prost(bool, tag = "9")]
+ pub exclude_workspace_context: bool,
+ #[prost(message, repeated, tag = "10")]
+ pub selected_subagent_models: Vec<CursorModelRequest>,
+ #[prost(string, tag = "11")]
+ pub conversation_group_id: String,
+ #[prost(bool, tag = "12")]
+ pub client_supports_inline_images: bool,
+}
+
+#[derive(Clone, PartialEq, Message)]
+pub struct ConversationState {
+ #[prost(message, repeated, tag = "1")]
+ pub messages: Vec<ConversationMessage>,
+}
+
+#[derive(Clone, PartialEq, Message)]
+pub struct ConversationMessage {
+ #[prost(string, tag = "1")]
+ pub role: String,
+ #[prost(string, tag = "2")]
+ pub text: String,
+}
+
+#[derive(Clone, PartialEq, Message)]
+pub struct Action {
+ #[prost(message, optional, tag = "1")]
+ pub user_message_action: Option<UserMessageAction>,
+}
+
+#[derive(Clone, PartialEq, Message)]
+pub struct UserMessageAction {
+ #[prost(message, optional, tag = "1")]
+ pub user_message: Option<UserMessage>,
+}
+
+#[derive(Clone, PartialEq, Message)]
+pub struct UserMessage {
+ #[prost(string, tag = "1")]
+ pub text: String,
+ #[prost(string, tag = "2")]
+ pub message_id: String,
+ #[prost(message, optional, tag = "3")]
+ pub selected_context: Option<SelectedContext>,
+ #[prost(string, tag = "4")]
+ pub mode: String,
+}
+
+#[derive(Clone, PartialEq, Message)]
+pub struct SelectedContext {
+ #[prost(message, repeated, tag = "1")]
+ pub selected_images: Vec<SelectedImage>,
+}
+
+#[derive(Clone, PartialEq, Message)]
+pub struct McpTools {
+ #[prost(message, repeated, tag = "1")]
+ pub tools: Vec<McpTool>,
+}
+
+#[derive(Clone, PartialEq, Message)]
+pub struct McpTool {
+ #[prost(string, tag = "1")]
+ pub name: String,
+ #[prost(string, tag = "2")]
+ pub description: String,
+ #[prost(string, tag = "3")]
+ pub input_schema: String,
+}
+
+#[derive(Clone, PartialEq, Message)]
+pub struct ClientHeartbeat {}
+
+#[derive(Clone, PartialEq, Message)]
+pub struct CursorModel {
+ #[prost(string, tag = "1")]
+ pub model_id: String,
+ #[prost(message, repeated, tag = "2")]
+ pub parameters: Vec<ModelParameter>,
+}
+
+#[derive(Clone, PartialEq, Message)]
+pub struct CursorModelRequest {
+ #[prost(string, tag = "1")]
+ pub model_id: String,
+ #[prost(message, repeated, tag = "2")]
+ pub parameters: Vec<ModelParameter>,
+}
+
+#[derive(Clone, PartialEq, Message)]
+pub struct ModelParameter {
+ #[prost(string, tag = "1")]
+ pub id: String,
+ #[prost(string, tag = "2")]
+ pub value: String,
+}
+
+#[derive(Clone, PartialEq, Message)]
+pub struct SelectedImage {
+ #[prost(string, tag = "1")]
+ pub data: String,
+ #[prost(string, tag = "2")]
+ pub uuid: String,
+ #[prost(string, tag = "3")]
+ pub path: String,
+ #[prost(string, tag = "4")]
+ pub mime_type: String,
+}
+
+// ---------------------------------------------------------------------------
+// Agent server message (response)
+// ---------------------------------------------------------------------------
+
+#[derive(Clone, PartialEq, Message)]
+pub struct AgentServerMessage {
+ #[prost(message, optional, tag = "1")]
+ pub interaction_update: Option<InteractionUpdate>,
+ #[prost(message, optional, tag = "3")]
+ pub exec_server_message: Option<ExecServerMessage>,
+}
+
+#[derive(Clone, PartialEq, Message)]
+pub struct InteractionUpdate {
+ #[prost(message, optional, tag = "1")]
+ pub thinking_delta: Option<ThinkingDelta>,
+ #[prost(message, optional, tag = "2")]
+ pub text_delta: Option<TextDelta>,
+ #[prost(message, optional, tag = "3")]
+ pub turn_ended: Option<TurnEnded>,
+}
+
+#[derive(Clone, PartialEq, Message)]
+pub struct ThinkingDelta {
+ #[prost(string, tag = "1")]
+ pub text: String,
+}
+
+#[derive(Clone, PartialEq, Message)]
+pub struct TextDelta {
+ #[prost(string, tag = "1")]
+ pub text: String,
+}
+
+#[derive(Clone, PartialEq, Message)]
+pub struct TurnEnded {
+ #[prost(uint64, tag = "1")]
+ pub input_tokens: u64,
+ #[prost(uint64, tag = "2")]
+ pub output_tokens: u64,
+ #[prost(uint64, tag = "3")]
+ pub cache_read_tokens: u64,
+ #[prost(uint64, tag = "4")]
+ pub cache_write_tokens: u64,
+}
+
+#[derive(Clone, PartialEq, Message)]
+pub struct ExecServerMessage {
+ #[prost(string, optional, tag = "1")]
+ pub notes_session_id: Option<String>,
+}
diff --git a/src/providers/cursor/request.rs b/src/providers/cursor/request.rs
new file mode 100644
index 0000000..27c6d6f
--- /dev/null
+++ b/src/providers/cursor/request.rs
@@ -0,0 +1,523 @@
+use crate::anthropic::schema::MessagesRequest;
+
+/// A selected image extracted from the request content blocks.
+#[derive(Debug, Clone)]
+pub struct CursorSelectedImage {
+ pub data: String,
+ pub uuid: String,
+ pub path: String,
+ pub mime_type: String,
+}
+
+/// Render the full Cursor prompt from an Anthropic MessagesRequest.
+///
+/// Mirrors the TypeScript `renderCursorPrompt` in
+/// `reference/typescript/src/providers/cursor/translate/request.ts`.
+///
+/// Includes:
+/// - System message (with billing-header filtering)
+/// - Conversation messages with content blocks
+/// - Tools block
+pub fn render_cursor_prompt(req: &MessagesRequest) -> String {
+ let mut sections: Vec<String> = Vec::new();
+
+ if let Some(system) = render_system(req) {
+ sections.push(format!("<system>\n{system}\n</system>"));
+ }
+
+ for message in &req.messages {
+ let content = render_message_content(message);
+ if let Some(c) = content {
+ sections.push(format!("<{}>\n{}\n</{}>", message.role, c, message.role));
+ }
+ }
+
+ // Tools block
+ if let Some(tools) = req.extra.get("tools").and_then(|v| v.as_array()) {
+ if !tools.is_empty() {
+ let tool_lines: Vec<String> = tools
+ .iter()
+ .filter_map(|t| {
+ let name = t.get("name").and_then(|n| n.as_str()).unwrap_or("");
+ let description = t.get("description").and_then(|d| d.as_str()).unwrap_or("");
+ let input_schema = t
+ .get("input_schema")
+ .cloned()
+ .unwrap_or(serde_json::Value::Object(Default::default()));
+ Some(format!(
+ "{}",
+ serde_json::json!({
+ "name": name,
+ "description": description,
+ "input_schema": input_schema,
+ })
+ ))
+ })
+ .collect();
+ if !tool_lines.is_empty() {
+ sections.push(format!("<tools>\n{}\n</tools>", tool_lines.join("\n")));
+ }
+ }
+ }
+
+ sections.join("\n\n")
+}
+
+/// Extract selected images from the request, mimicking `cursorSelectedImages`.
+///
+/// Only base64 source images are included. URL images are skipped.
+/// Images nested inside tool_result blocks are also collected.
+pub fn cursor_selected_images(req: &MessagesRequest) -> Vec<CursorSelectedImage> {
+ let mut images: Vec<CursorSelectedImage> = Vec::new();
+ let mut index: u32 = 0;
+
+ for message in &req.messages {
+ let blocks = message_blocks(message);
+ for block in &blocks {
+ collect_image_blocks(block, &mut index, &mut images);
+ }
+ }
+
+ images
+}
+
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+
+fn render_system(req: &MessagesRequest) -> Option<String> {
+ let system_value = req.extra.get("system")?;
+ let text = match system_value {
+ serde_json::Value::String(s) => s.clone(),
+ serde_json::Value::Array(blocks) => {
+ let parts: Vec<&str> = blocks
+ .iter()
+ .filter_map(|b| {
+ if b.get("type").and_then(|t| t.as_str()) == Some("text") {
+ b.get("text").and_then(|t| t.as_str())
+ } else {
+ None
+ }
+ })
+ .filter(|line| !line.starts_with("x-anthropic-billing-header:"))
+ .collect();
+ if parts.is_empty() {
+ return None;
+ }
+ parts.join("\n\n")
+ }
+ _ => return None,
+ };
+ if text.is_empty() {
+ return None;
+ }
+ Some(text)
+}
+
+fn render_message_content(message: &crate::anthropic::schema::Message) -> Option<String> {
+ let blocks = message_blocks(message);
+ let rendered: Vec<String> = blocks.iter().filter_map(render_block).collect();
+ if rendered.is_empty() {
+ None
+ } else {
+ Some(rendered.join("\n\n"))
+ }
+}
+
+fn render_block(block: &serde_json::Value) -> Option<String> {
+ let block_type = block.get("type").and_then(|t| t.as_str())?;
+ match block_type {
+ "text" => block
+ .get("text")
+ .and_then(|t| t.as_str())
+ .map(|s| s.to_string()),
+ "thinking" => {
+ let text = block.get("thinking").and_then(|t| t.as_str()).unwrap_or("");
+ Some(format!("<thinking>\n{text}\n</thinking>"))
+ }
+ "image" => {
+ let source = block.get("source")?;
+ match source.get("type").and_then(|t| t.as_str()) {
+ Some("url") => {
+ let url = source.get("url").and_then(|u| u.as_str()).unwrap_or("");
+ Some(format!("[image: {url}]"))
+ }
+ _ => {
+ let media_type = source
+ .get("media_type")
+ .and_then(|m| m.as_str())
+ .unwrap_or("unknown");
+ let data = source.get("data").and_then(|d| d.as_str()).unwrap_or("");
+ Some(format!(
+ "[image: {media_type}, {} base64 chars]",
+ data.len()
+ ))
+ }
+ }
+ }
+ "tool_use" => {
+ let id = block.get("id").and_then(|i| i.as_str()).unwrap_or("");
+ let name = block.get("name").and_then(|n| n.as_str()).unwrap_or("");
+ let input = block
+ .get("input")
+ .and_then(|i| serde_json::to_string(i).ok())
+ .unwrap_or_else(|| "{}".to_string());
+ Some(format!(
+ "<tool_use id=\"{id}\" name=\"{name}\">\n{input}\n</tool_use>"
+ ))
+ }
+ "tool_result" => {
+ let tool_use_id = block
+ .get("tool_use_id")
+ .and_then(|t| t.as_str())
+ .unwrap_or("");
+ let is_error = block
+ .get("is_error")
+ .and_then(|e| e.as_bool())
+ .unwrap_or(false);
+ let error_attr = if is_error { " is_error=\"true\"" } else { "" };
+ let content = render_tool_result_content(block);
+ Some(format!(
+ "<tool_result tool_use_id=\"{tool_use_id}\"{error_attr}>\n{content}\n</tool_result>"
+ ))
+ }
+ "server_tool_use" => {
+ let id = block.get("id").and_then(|i| i.as_str()).unwrap_or("");
+ let name = block.get("name").and_then(|n| n.as_str()).unwrap_or("");
+ let input = block
+ .get("input")
+ .and_then(|i| serde_json::to_string(i).ok())
+ .unwrap_or_else(|| "{}".to_string());
+ Some(format!(
+ "<server_tool_use id=\"{id}\" name=\"{name}\">\n{input}\n</server_tool_use>"
+ ))
+ }
+ "web_search_tool_result" => {
+ let tool_use_id = block
+ .get("tool_use_id")
+ .and_then(|t| t.as_str())
+ .unwrap_or("");
+ let content = block
+ .get("content")
+ .and_then(|c| serde_json::to_string(c).ok())
+ .unwrap_or_else(|| "{}".to_string());
+ Some(format!(
+ "<web_search_tool_result tool_use_id=\"{tool_use_id}\">\n{content}\n</web_search_tool_result>"
+ ))
+ }
+ _ => {
+ // Unsupported block type - render as text placeholder
+ block
+ .get("text")
+ .and_then(|t| t.as_str())
+ .map(|s| s.to_string())
+ }
+ }
+}
+
+fn render_tool_result_content(block: &serde_json::Value) -> String {
+ let content = match block.get("content") {
+ Some(serde_json::Value::String(s)) => return s.clone(),
+ Some(serde_json::Value::Array(arr)) => arr.clone(),
+ _ => return String::new(),
+ };
+
+ let parts: Vec<String> = content
+ .iter()
+ .filter_map(render_tool_result_block)
+ .collect();
+ parts.join("\n\n")
+}
+
+fn render_tool_result_block(block: &serde_json::Value) -> Option<String> {
+ let block_type = block.get("type").and_then(|t| t.as_str())?;
+ match block_type {
+ "text" | "image" | "tool_use" | "tool_result" | "thinking" => render_block(block),
+ _ => {
+ let type_str = block_type.to_string();
+ Some(format!("[unsupported tool result block: {type_str}]"))
+ }
+ }
+}
+
+fn message_blocks(message: &crate::anthropic::schema::Message) -> Vec<serde_json::Value> {
+ match &message.content {
+ serde_json::Value::String(s) => {
+ vec![serde_json::json!({"type": "text", "text": s})]
+ }
+ serde_json::Value::Array(arr) => arr.clone(),
+ _ => Vec::new(),
+ }
+}
+
+fn collect_image_blocks(
+ block: &serde_json::Value,
+ index: &mut u32,
+ images: &mut Vec<CursorSelectedImage>,
+) {
+ if block.get("type").and_then(|t| t.as_str()) == Some("image") {
+ let source = match block.get("source") {
+ Some(s) => s,
+ None => return,
+ };
+ if source.get("type").and_then(|t| t.as_str()) != Some("base64") {
+ return;
+ }
+ let data = source.get("data").and_then(|d| d.as_str()).unwrap_or("");
+ let media_type = source
+ .get("media_type")
+ .and_then(|m| m.as_str())
+ .unwrap_or("image/png");
+ let uuid = uuid::Uuid::new_v4().to_string();
+ *index += 1;
+ let extension = image_extension(media_type);
+ images.push(CursorSelectedImage {
+ data: data.to_string(),
+ uuid,
+ path: format!("claude-image-{index}.{extension}"),
+ mime_type: media_type.to_string(),
+ });
+ return;
+ }
+
+ // Recurse into tool_result blocks for nested images
+ if block.get("type").and_then(|t| t.as_str()) == Some("tool_result") {
+ let content = match block.get("content") {
+ Some(serde_json::Value::Array(arr)) => arr.clone(),
+ _ => return,
+ };
+ for child in &content {
+ let child_type = child.get("type").and_then(|t| t.as_str());
+ matches!(
+ child_type,
+ Some("text" | "image" | "tool_use" | "tool_result" | "thinking")
+ );
+ collect_image_blocks(child, index, images);
+ }
+ }
+}
+
+fn image_extension(media_type: &str) -> &'static str {
+ match media_type {
+ "image/jpeg" => "jpg",
+ "image/png" => "png",
+ "image/gif" => "gif",
+ "image/webp" => "webp",
+ _ => "img",
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn renders_system_message() {
+ let req: MessagesRequest = serde_json::from_value(serde_json::json!({
+ "model": "cursor:gpt-5.5",
+ "system": "be direct",
+ "messages": [{"role": "user", "content": "hello"}]
+ }))
+ .unwrap();
+ let rendered = render_cursor_prompt(&req);
+ assert!(rendered.contains("<system>"));
+ assert!(rendered.contains("be direct"));
+ assert!(rendered.contains("</system>"));
+ assert!(rendered.contains("<user>"));
+ assert!(rendered.contains("hello"));
+ assert!(rendered.contains("</user>"));
+ }
+
+ #[test]
+ fn renders_tools_section() {
+ let req: MessagesRequest = serde_json::from_value(serde_json::json!({
+ "model": "cursor:gpt-5.5",
+ "messages": [{"role": "user", "content": "hi"}],
+ "tools": [{"name": "Read", "description": "read files", "input_schema": {"type": "object"}}]
+ }))
+ .unwrap();
+ let rendered = render_cursor_prompt(&req);
+ assert!(rendered.contains("<tools>"));
+ assert!(rendered.contains("Read"));
+ }
+
+ #[test]
+ fn filters_billing_headers_from_system() {
+ let req: MessagesRequest = serde_json::from_value(serde_json::json!({
+ "model": "cursor:gpt-5.5",
+ "system": [
+ {"type": "text", "text": "keep this"},
+ {"type": "text", "text": "x-anthropic-billing-header: skip-me"}
+ ],
+ "messages": [{"role": "user", "content": "hello"}]
+ }))
+ .unwrap();
+ let rendered = render_cursor_prompt(&req);
+ assert!(rendered.contains("keep this"));
+ assert!(!rendered.contains("x-anthropic-billing-header"));
+ }
+
+ #[test]
+ fn collects_selected_images() {
+ let req: MessagesRequest = serde_json::from_value(serde_json::json!({
+ "model": "cursor:gpt-5.5",
+ "messages": [{
+ "role": "user",
+ "content": [
+ {"type": "text", "text": "hi"},
+ {"type": "image", "source": {"type": "base64", "media_type": "image/png", "data": "AAAA"}}
+ ]
+ }]
+ }))
+ .unwrap();
+ let images = cursor_selected_images(&req);
+ assert_eq!(images.len(), 1);
+ assert_eq!(images[0].mime_type, "image/png");
+ assert_eq!(images[0].data, "AAAA");
+ }
+
+ #[test]
+ fn skips_url_images_in_selected() {
+ let req: MessagesRequest = serde_json::from_value(serde_json::json!({
+ "model": "cursor:gpt-5.5",
+ "messages": [{
+ "role": "user",
+ "content": [
+ {"type": "image", "source": {"type": "url", "url": "https://example.com/img.png"}}
+ ]
+ }]
+ }))
+ .unwrap();
+ let images = cursor_selected_images(&req);
+ assert_eq!(images.len(), 0);
+ }
+
+ #[test]
+ fn renders_url_image_placeholder() {
+ let req: MessagesRequest = serde_json::from_value(serde_json::json!({
+ "model": "cursor:gpt-5.5",
+ "messages": [{
+ "role": "user",
+ "content": [
+ {"type": "image", "source": {"type": "url", "url": "https://example.com/img.png"}}
+ ]
+ }]
+ }))
+ .unwrap();
+ let rendered = render_cursor_prompt(&req);
+ assert!(rendered.contains("[image: https://example.com/img.png]"));
+ }
+
+ #[test]
+ fn renders_thinking_blocks() {
+ let req: MessagesRequest = serde_json::from_value(serde_json::json!({
+ "model": "cursor:gpt-5.5",
+ "messages": [{"role": "assistant", "content": [
+ {"type": "thinking", "thinking": "let me think..."},
+ {"type": "text", "text": "done"}
+ ]}]
+ }))
+ .unwrap();
+ let rendered = render_cursor_prompt(&req);
+ assert!(rendered.contains("<thinking>"));
+ assert!(rendered.contains("let me think..."));
+ assert!(rendered.contains("done"));
+ }
+
+ #[test]
+ fn renders_tool_use_blocks() {
+ let req: MessagesRequest = serde_json::from_value(serde_json::json!({
+ "model": "cursor:gpt-5.5",
+ "messages": [{"role": "assistant", "content": [
+ {"type": "tool_use", "id": "tu1", "name": "Read", "input": {"path": "/tmp"}}
+ ]}]
+ }))
+ .unwrap();
+ let rendered = render_cursor_prompt(&req);
+ assert!(rendered.contains("<tool_use id=\"tu1\" name=\"Read\">"));
+ }
+
+ #[test]
+ fn renders_tool_result_with_content_blocks() {
+ let req: MessagesRequest = serde_json::from_value(serde_json::json!({
+ "model": "cursor:gpt-5.5",
+ "messages": [{"role": "user", "content": [
+ {"type": "tool_result", "tool_use_id": "tu1", "content": [
+ {"type": "text", "text": "file contents"}
+ ]}
+ ]}]
+ }))
+ .unwrap();
+ let rendered = render_cursor_prompt(&req);
+ assert!(rendered.contains("<tool_result tool_use_id=\"tu1\">"));
+ assert!(rendered.contains("file contents"));
+ }
+
+ #[test]
+ fn handles_unsupported_block_types() {
+ let req: MessagesRequest = serde_json::from_value(serde_json::json!({
+ "model": "cursor:gpt-5.5",
+ "messages": [{"role": "user", "content": [
+ {"type": "unknown_block", "text": "some fallback text"}
+ ]}]
+ }))
+ .unwrap();
+ let rendered = render_cursor_prompt(&req);
+ // Unsupported blocks fall back to text rendering if they have a text field
+ assert!(rendered.contains("some fallback text"));
+ }
+
+ #[test]
+ fn empty_messages_renders_emptyish() {
+ let req: MessagesRequest = serde_json::from_value(serde_json::json!({
+ "model": "cursor:gpt-5.5",
+ "messages": [{"role": "user", "content": ""}]
+ }))
+ .unwrap();
+ let rendered = render_cursor_prompt(&req);
+ assert!(rendered.is_empty() || !rendered.is_empty());
+ }
+
+ #[test]
+ fn tool_result_with_nested_image() {
+ let req: MessagesRequest = serde_json::from_value(serde_json::json!({
+ "model": "cursor:gpt-5.5",
+ "messages": [{"role": "user", "content": [
+ {"type": "tool_result", "tool_use_id": "tu1", "content": [
+ {"type": "image", "source": {"type": "base64", "media_type": "image/jpeg", "data": "BBBB"}}
+ ]}
+ ]}]
+ }))
+ .unwrap();
+ let images = cursor_selected_images(&req);
+ assert_eq!(images.len(), 1);
+ assert_eq!(images[0].mime_type, "image/jpeg");
+ assert_eq!(images[0].data, "BBBB");
+ }
+
+ #[test]
+ fn renders_server_tool_use() {
+ let req: MessagesRequest = serde_json::from_value(serde_json::json!({
+ "model": "cursor:gpt-5.5",
+ "messages": [{"role": "assistant", "content": [
+ {"type": "server_tool_use", "id": "st1", "name": "WebSearch", "input": {"query": "rust"}}
+ ]}]
+ }))
+ .unwrap();
+ let rendered = render_cursor_prompt(&req);
+ assert!(rendered.contains("<server_tool_use id=\"st1\" name=\"WebSearch\">"));
+ }
+
+ #[test]
+ fn renders_web_search_tool_result() {
+ let req: MessagesRequest = serde_json::from_value(serde_json::json!({
+ "model": "cursor:gpt-5.5",
+ "messages": [{"role": "user", "content": [
+ {"type": "web_search_tool_result", "tool_use_id": "ws1", "content": {"results": []}}
+ ]}]
+ }))
+ .unwrap();
+ let rendered = render_cursor_prompt(&req);
+ assert!(rendered.contains("<web_search_tool_result tool_use_id=\"ws1\">"));
+ }
+}
diff --git a/src/providers/cursor/response.rs b/src/providers/cursor/response.rs
new file mode 100644
index 0000000..7e87765
--- /dev/null
+++ b/src/providers/cursor/response.rs
@@ -0,0 +1,345 @@
+use crate::anthropic::schema::MessagesRequest;
+use crate::providers::cursor::client::{
+ CursorUpstreamResponse, decode_frame_payload, decode_upstream_frames,
+};
+use crate::providers::cursor::connect::{FLAG_END, parse_connect_error};
+use crate::providers::cursor::proto::AgentServerMessage;
+
+/// A decoded event from the Cursor upstream response stream.
+#[derive(Debug, Clone)]
+pub enum CursorStreamEvent {
+ Session {
+ session_id: String,
+ },
+ ThinkingDelta {
+ text: String,
+ },
+ TextDelta {
+ text: String,
+ },
+ Usage {
+ input_tokens: u64,
+ output_tokens: u64,
+ cache_read_tokens: u64,
+ cache_write_tokens: u64,
+ },
+ End,
+}
+
+/// Decode upstream response bytes into a sequence of CursorStreamEvents.
+///
+/// Returns both the events and the final usage for the response, since the
+/// upstream may send multiple update frames.
+pub fn decode_upstream_response(body: &[u8]) -> Result<Vec<CursorStreamEvent>, String> {
+ let frames = decode_upstream_frames(body).map_err(|e| e.to_string())?;
+ let mut events = Vec::new();
+
+ for frame in &frames {
+ if frame.flags & FLAG_END != 0 {
+ // Check for Connect error in end frame
+ if !frame.payload.is_empty() {
+ if let Some(err) = parse_connect_error(&frame.payload) {
+ return Err(format!("{err}"));
+ }
+ }
+ events.push(CursorStreamEvent::End);
+ continue;
+ }
+
+ let msg = match decode_frame_payload(frame) {
+ Ok(m) => m,
+ Err(_) => continue,
+ };
+
+ events_from_message(&msg, &mut events);
+ }
+
+ Ok(events)
+}
+
+/// Build an accumulated Anthropic response JSON from upstream bytes for
+/// non-streaming mode.
+pub fn decode_cursor_upstream(
+ upstream: &CursorUpstreamResponse,
+ message_id: &str,
+ model: &str,
+) -> Result<serde_json::Value, String> {
+ let events = decode_upstream_response(&upstream.body)?;
+
+ let mut text_content = String::new();
+ let mut final_input_tokens: u64 = 0;
+ let mut final_output_tokens: u64 = 0;
+
+ for event in &events {
+ match event {
+ CursorStreamEvent::TextDelta { text } => text_content.push_str(text),
+ CursorStreamEvent::Usage {
+ input_tokens,
+ output_tokens,
+ ..
+ } => {
+ final_input_tokens = *input_tokens;
+ final_output_tokens = *output_tokens;
+ }
+ CursorStreamEvent::End => break,
+ _ => {}
+ }
+ }
+
+ let input_tokens = final_input_tokens.max(estimate_input_tokens(&text_content));
+
+ Ok(serde_json::json!({
+ "id": message_id,
+ "type": "message",
+ "role": "assistant",
+ "content": [
+ {"type": "text", "text": text_content}
+ ],
+ "model": model,
+ "stop_reason": "end_turn",
+ "stop_sequence": null,
+ "usage": {
+ "input_tokens": input_tokens,
+ "output_tokens": final_output_tokens,
+ "cache_creation_input_tokens": 0,
+ "cache_read_input_tokens": 0
+ }
+ }))
+}
+
+fn estimate_input_tokens(_content: &str) -> u64 {
+ // Rough upper bound: 4 chars per token for input estimation
+ (_content.len() / 4) as u64
+}
+
+fn events_from_message(msg: &AgentServerMessage, events: &mut Vec<CursorStreamEvent>) {
+ // Check for exec_server_message with session info
+ if let Some(ref exec) = msg.exec_server_message {
+ if let Some(ref session_id) = exec.notes_session_id {
+ if !session_id.is_empty() {
+ events.push(CursorStreamEvent::Session {
+ session_id: session_id.clone(),
+ });
+ }
+ }
+ }
+
+ if let Some(ref update) = msg.interaction_update {
+ // Thinking delta
+ if let Some(ref td) = update.thinking_delta {
+ if !td.text.is_empty() {
+ events.push(CursorStreamEvent::ThinkingDelta {
+ text: td.text.clone(),
+ });
+ }
+ }
+
+ // Text delta
+ if let Some(ref td) = update.text_delta {
+ if !td.text.is_empty() {
+ events.push(CursorStreamEvent::TextDelta {
+ text: td.text.clone(),
+ });
+ }
+ }
+
+ // Turn ended (usage + end)
+ if let Some(ref te) = update.turn_ended {
+ events.push(CursorStreamEvent::Usage {
+ input_tokens: te.input_tokens,
+ output_tokens: te.output_tokens,
+ cache_read_tokens: te.cache_read_tokens,
+ cache_write_tokens: te.cache_write_tokens,
+ });
+ events.push(CursorStreamEvent::End);
+ }
+ }
+}
+
+/// Extract an estimate of input tokens from a MessagesRequest for usage
+/// reporting. This is a rough heuristic based on JSON string length.
+pub fn estimate_request_input_tokens(req: &MessagesRequest) -> u64 {
+ let prompt = super::request::render_cursor_prompt(req);
+ (prompt.len() / 4).max(1) as u64
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::providers::cursor::connect::encode_connect_frame;
+ use crate::providers::cursor::proto::*;
+ use prost::Message;
+
+ fn make_text_frame(text: &str) -> Vec<u8> {
+ let msg = AgentServerMessage {
+ interaction_update: Some(InteractionUpdate {
+ thinking_delta: None,
+ text_delta: Some(TextDelta {
+ text: text.to_string(),
+ }),
+ turn_ended: None,
+ }),
+ exec_server_message: None,
+ };
+ let mut payload = Vec::new();
+ msg.encode(&mut payload).unwrap();
+ encode_connect_frame(&payload, 0).to_vec()
+ }
+
+ fn make_usage_frame(input: u64, output: u64) -> Vec<u8> {
+ let msg = AgentServerMessage {
+ interaction_update: Some(InteractionUpdate {
+ thinking_delta: None,
+ text_delta: None,
+ turn_ended: Some(TurnEnded {
+ input_tokens: input,
+ output_tokens: output,
+ cache_read_tokens: 0,
+ cache_write_tokens: 0,
+ }),
+ }),
+ exec_server_message: None,
+ };
+ let mut payload = Vec::new();
+ msg.encode(&mut payload).unwrap();
+ encode_connect_frame(&payload, 0).to_vec()
+ }
+
+ fn make_end_frame() -> Vec<u8> {
+ encode_connect_frame(b"", 2).to_vec()
+ }
+
+ #[test]
+ fn decodes_text_and_usage_events() {
+ let mut body = Vec::new();
+ body.extend_from_slice(&make_text_frame("Hello"));
+ body.extend_from_slice(&make_text_frame(" world"));
+ body.extend_from_slice(&make_usage_frame(10, 5));
+ body.extend_from_slice(&make_end_frame());
+
+ let events = decode_upstream_response(&body).unwrap();
+ assert_eq!(events.len(), 5);
+ assert!(matches!(events[0], CursorStreamEvent::TextDelta { .. }));
+ assert!(matches!(events[1], CursorStreamEvent::TextDelta { .. }));
+ assert!(matches!(events[2], CursorStreamEvent::Usage { .. }));
+ assert!(matches!(events[3], CursorStreamEvent::End));
+ assert!(matches!(events[4], CursorStreamEvent::End));
+ }
+
+ #[test]
+ fn decodes_thinking_delta() {
+ let msg = AgentServerMessage {
+ interaction_update: Some(InteractionUpdate {
+ thinking_delta: Some(ThinkingDelta {
+ text: "thinking...".to_string(),
+ }),
+ text_delta: None,
+ turn_ended: None,
+ }),
+ exec_server_message: None,
+ };
+ let mut payload = Vec::new();
+ msg.encode(&mut payload).unwrap();
+ let body = encode_connect_frame(&payload, 0).to_vec();
+
+ let events = decode_upstream_response(&body).unwrap();
+ assert_eq!(events.len(), 1);
+ if let CursorStreamEvent::ThinkingDelta { text } = &events[0] {
+ assert_eq!(text, "thinking...");
+ } else {
+ panic!("expected ThinkingDelta");
+ }
+ }
+
+ #[test]
+ fn decodes_session_event() {
+ let msg = AgentServerMessage {
+ interaction_update: None,
+ exec_server_message: Some(ExecServerMessage {
+ notes_session_id: Some("session-123".to_string()),
+ }),
+ };
+ let mut payload = Vec::new();
+ msg.encode(&mut payload).unwrap();
+ let body = encode_connect_frame(&payload, 0).to_vec();
+
+ let events = decode_upstream_response(&body).unwrap();
+ assert_eq!(events.len(), 1);
+ if let CursorStreamEvent::Session { session_id } = &events[0] {
+ assert_eq!(session_id, "session-123");
+ } else {
+ panic!("expected Session");
+ }
+ }
+
+ #[test]
+ fn accumulate_response_produces_anthropic_json() {
+ let mut body = Vec::new();
+ body.extend_from_slice(&make_text_frame("Hello world"));
+ body.extend_from_slice(&make_usage_frame(15, 3));
+ body.extend_from_slice(&make_end_frame());
+
+ let upstream = CursorUpstreamResponse {
+ status: 200,
+ body,
+ error_detail: None,
+ };
+
+ let json = decode_cursor_upstream(&upstream, "msg_test", "cursor-test").unwrap();
+ assert_eq!(json["id"], "msg_test");
+ assert_eq!(json["content"][0]["text"], "Hello world");
+ assert_eq!(json["usage"]["input_tokens"].as_u64(), Some(15));
+ assert_eq!(json["usage"]["output_tokens"].as_u64(), Some(3));
+ assert_eq!(
+ json["usage"]["cache_creation_input_tokens"].as_u64(),
+ Some(0)
+ );
+ assert_eq!(json["usage"]["cache_read_input_tokens"].as_u64(), Some(0));
+ assert_eq!(json["stop_reason"], "end_turn");
+ }
+
+ #[test]
+ fn empty_upstream_produces_empty_response() {
+ let upstream = CursorUpstreamResponse {
+ status: 200,
+ body: Vec::new(),
+ error_detail: None,
+ };
+ let json = decode_cursor_upstream(&upstream, "msg_empty", "cursor-test").unwrap();
+ assert_eq!(json["content"][0]["text"], "");
+ }
+
+ #[test]
+ fn connect_end_frame_with_error_is_rejected() {
+ let json_err = serde_json::json!({
+ "error": {"code": "resource_exhausted", "message": "quota exceeded"}
+ });
+ let payload = serde_json::to_vec(&json_err).unwrap();
+ let frame = encode_connect_frame(&payload, FLAG_END);
+ let result = decode_upstream_response(&frame);
+ assert!(result.is_err());
+ assert!(result.unwrap_err().contains("quota exceeded"));
+ }
+
+ #[test]
+ fn multiple_text_deltas_accumulate() {
+ let mut body = Vec::new();
+ body.extend_from_slice(&make_text_frame("Hello "));
+ body.extend_from_slice(&make_text_frame("world"));
+ body.extend_from_slice(&make_usage_frame(10, 2));
+ body.extend_from_slice(&make_end_frame());
+
+ let events = decode_upstream_response(&body).unwrap();
+ let text: String = events
+ .iter()
+ .filter_map(|e| {
+ if let CursorStreamEvent::TextDelta { text } = e {
+ Some(text.as_str())
+ } else {
+ None
+ }
+ })
+ .collect();
+ assert_eq!(text, "Hello world");
+ }
+}
diff --git a/src/providers/cursor/sse.rs b/src/providers/cursor/sse.rs
new file mode 100644
index 0000000..5742323
--- /dev/null
+++ b/src/providers/cursor/sse.rs
@@ -0,0 +1,548 @@
+use crate::providers::cursor::client::CursorUpstreamResponse;
+use crate::providers::cursor::response::{CursorStreamEvent, decode_upstream_response};
+
+/// SSE event name constants.
+pub const EVENT_MESSAGE_START: &str = "message_start";
+pub const EVENT_CONTENT_BLOCK_START: &str = "content_block_start";
+pub const EVENT_CONTENT_BLOCK_DELTA: &str = "content_block_delta";
+pub const EVENT_CONTENT_BLOCK_STOP: &str = "content_block_stop";
+pub const EVENT_MESSAGE_DELTA: &str = "message_delta";
+pub const EVENT_MESSAGE_STOP: &str = "message_stop";
+pub const EVENT_PING: &str = "ping";
+pub const EVENT_ERROR: &str = "error";
+
+/// Frame upstream Cursor response bytes into Anthropic SSE event bytes.
+///
+/// Produces the standard message lifecycle:
+/// 1. message_start (with initial usage)
+/// 2. content_block_start (text)
+/// 3. content_block_delta (text deltas) / content_block_delta (thinking deltas)
+/// 4. content_block_stop
+/// 5. message_delta (with final usage and stop_reason)
+/// 6. message_stop
+pub fn frame_cursor_stream(
+ upstream: &CursorUpstreamResponse,
+ message_id: &str,
+ model: &str,
+) -> Vec<u8> {
+ let events = match decode_upstream_response(&upstream.body) {
+ Ok(e) => e,
+ Err(e) => {
+ return format_sse_error(&e);
+ }
+ };
+
+ let mut sse = Vec::new();
+ let mut framer = CursorSseFramer::new(&mut sse, message_id, model);
+
+ for event in &events {
+ match event {
+ CursorStreamEvent::ThinkingDelta { text } => {
+ framer.emit_thinking_delta(text);
+ }
+ CursorStreamEvent::TextDelta { text } => {
+ framer.emit_text_delta(text);
+ }
+ CursorStreamEvent::Usage {
+ input_tokens,
+ output_tokens,
+ cache_read_tokens,
+ cache_write_tokens,
+ } => {
+ framer.record_usage(
+ *input_tokens,
+ *output_tokens,
+ *cache_read_tokens,
+ *cache_write_tokens,
+ );
+ }
+ CursorStreamEvent::End => {
+ framer.emit_final_message("end_turn");
+ }
+ CursorStreamEvent::Session { .. } => {
+ // Session events are informational, not mapped to SSE
+ }
+ }
+ }
+
+ framer.finalize();
+ sse
+}
+
+/// Format an SSE error event.
+fn format_sse_error(error: &str) -> Vec<u8> {
+ let data = serde_json::json!({
+ "type": "error",
+ "error": {
+ "type": "api_error",
+ "message": error
+ }
+ });
+ format_sse_event_bytes("error", &data)
+}
+
+/// Format a single SSE event into bytes.
+fn format_sse_event_bytes(event: &str, data: &serde_json::Value) -> Vec<u8> {
+ let json_str = serde_json::to_string(data).unwrap_or_else(|_| "{}".to_string());
+ format!("event: {event}\ndata: {json_str}\n\n").into_bytes()
+}
+
+// ---------------------------------------------------------------------------
+// SSE Framer
+// ---------------------------------------------------------------------------
+
+/// SSE framer that tracks state to produce well-formed Anthropic SSE events.
+pub struct CursorSseFramer<'a> {
+ output: &'a mut Vec<u8>,
+ message_id: &'a str,
+ model: &'a str,
+ started: bool,
+ thinking_open: bool,
+ text_open: bool,
+ next_index: i32,
+ thinking_index: i32,
+ text_index: i32,
+ usage_input_tokens: u64,
+ usage_output_tokens: u64,
+ finalized: bool,
+}
+
+impl<'a> CursorSseFramer<'a> {
+ pub fn new(output: &'a mut Vec<u8>, message_id: &'a str, model: &'a str) -> Self {
+ Self {
+ output,
+ message_id,
+ model,
+ started: false,
+ thinking_open: false,
+ text_open: false,
+ next_index: 0,
+ thinking_index: -1,
+ text_index: -1,
+ usage_input_tokens: 0,
+ usage_output_tokens: 0,
+ finalized: false,
+ }
+ }
+
+ fn ensure_start(&mut self) {
+ if self.started {
+ return;
+ }
+ self.started = true;
+
+ let data = serde_json::json!({
+ "type": "message_start",
+ "message": {
+ "id": self.message_id,
+ "type": "message",
+ "role": "assistant",
+ "content": [],
+ "model": self.model,
+ "stop_reason": null,
+ "stop_sequence": null,
+ "usage": {
+ "input_tokens": self.usage_input_tokens.max(1),
+ "output_tokens": 0,
+ "cache_creation_input_tokens": 0,
+ "cache_read_input_tokens": 0
+ }
+ }
+ });
+ self.output
+ .extend_from_slice(&format_sse_event_bytes(EVENT_MESSAGE_START, &data));
+ }
+
+ fn open_thinking(&mut self) {
+ if self.thinking_open {
+ return;
+ }
+ self.ensure_start();
+ self.thinking_open = true;
+ self.thinking_index = self.next_index;
+ self.next_index += 1;
+
+ let data = serde_json::json!({
+ "type": "content_block_start",
+ "index": self.thinking_index,
+ "content_block": {
+ "type": "thinking",
+ "thinking": "",
+ "signature": ""
+ }
+ });
+ self.output
+ .extend_from_slice(&format_sse_event_bytes(EVENT_CONTENT_BLOCK_START, &data));
+ }
+
+ fn open_text(&mut self) {
+ if self.text_open {
+ return;
+ }
+ self.ensure_start();
+ self.text_open = true;
+ self.text_index = self.next_index;
+ self.next_index += 1;
+
+ let data = serde_json::json!({
+ "type": "content_block_start",
+ "index": self.text_index,
+ "content_block": {
+ "type": "text",
+ "text": ""
+ }
+ });
+ self.output
+ .extend_from_slice(&format_sse_event_bytes(EVENT_CONTENT_BLOCK_START, &data));
+ }
+
+ fn close_open_blocks(&mut self) {
+ if self.thinking_open {
+ let data = serde_json::json!({
+ "type": "content_block_stop",
+ "index": self.thinking_index
+ });
+ self.output
+ .extend_from_slice(&format_sse_event_bytes(EVENT_CONTENT_BLOCK_STOP, &data));
+ self.thinking_open = false;
+ }
+ if self.text_open {
+ let data = serde_json::json!({
+ "type": "content_block_stop",
+ "index": self.text_index
+ });
+ self.output
+ .extend_from_slice(&format_sse_event_bytes(EVENT_CONTENT_BLOCK_STOP, &data));
+ self.text_open = false;
+ }
+ }
+
+ pub fn emit_thinking_delta(&mut self, text: &str) {
+ self.open_thinking();
+ let data = serde_json::json!({
+ "type": "content_block_delta",
+ "index": self.thinking_index,
+ "delta": {
+ "type": "thinking_delta",
+ "thinking": text
+ }
+ });
+ self.output
+ .extend_from_slice(&format_sse_event_bytes(EVENT_CONTENT_BLOCK_DELTA, &data));
+ }
+
+ pub fn emit_text_delta(&mut self, text: &str) {
+ // Close thinking block if open before starting text
+ if self.thinking_open {
+ let data = serde_json::json!({
+ "type": "content_block_stop",
+ "index": self.thinking_index
+ });
+ self.output
+ .extend_from_slice(&format_sse_event_bytes(EVENT_CONTENT_BLOCK_STOP, &data));
+ self.thinking_open = false;
+ }
+ self.open_text();
+ let data = serde_json::json!({
+ "type": "content_block_delta",
+ "index": self.text_index,
+ "delta": {
+ "type": "text_delta",
+ "text": text
+ }
+ });
+ self.output
+ .extend_from_slice(&format_sse_event_bytes(EVENT_CONTENT_BLOCK_DELTA, &data));
+ }
+
+ pub fn record_usage(
+ &mut self,
+ input_tokens: u64,
+ output_tokens: u64,
+ _cache_read_tokens: u64,
+ _cache_write_tokens: u64,
+ ) {
+ self.usage_input_tokens = input_tokens;
+ self.usage_output_tokens = output_tokens;
+ }
+
+ pub fn emit_final_message(&mut self, stop_reason: &str) {
+ if self.finalized {
+ return;
+ }
+ self.ensure_start();
+ self.close_open_blocks();
+
+ // message_delta
+ let data = serde_json::json!({
+ "type": "message_delta",
+ "delta": {
+ "stop_reason": stop_reason,
+ "stop_sequence": null
+ },
+ "usage": {
+ "input_tokens": self.usage_input_tokens.max(1),
+ "output_tokens": self.usage_output_tokens,
+ "cache_creation_input_tokens": 0,
+ "cache_read_input_tokens": 0
+ }
+ });
+ self.output
+ .extend_from_slice(&format_sse_event_bytes(EVENT_MESSAGE_DELTA, &data));
+
+ // message_stop
+ let data = serde_json::json!({
+ "type": "message_stop"
+ });
+ self.output
+ .extend_from_slice(&format_sse_event_bytes(EVENT_MESSAGE_STOP, &data));
+
+ self.finalized = true;
+ }
+
+ pub fn finalize(&mut self) {
+ if !self.finalized {
+ self.ensure_start();
+ self.close_open_blocks();
+ self.emit_final_message("end_turn");
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::providers::cursor::connect::encode_connect_frame;
+ use crate::providers::cursor::proto::*;
+ use prost::Message;
+
+ fn make_text_frame(text: &str) -> Vec<u8> {
+ let msg = AgentServerMessage {
+ interaction_update: Some(InteractionUpdate {
+ thinking_delta: None,
+ text_delta: Some(TextDelta {
+ text: text.to_string(),
+ }),
+ turn_ended: None,
+ }),
+ exec_server_message: None,
+ };
+ let mut payload = Vec::new();
+ msg.encode(&mut payload).unwrap();
+ encode_connect_frame(&payload, 0).to_vec()
+ }
+
+ fn make_usage_frame(input: u64, output: u64) -> Vec<u8> {
+ let msg = AgentServerMessage {
+ interaction_update: Some(InteractionUpdate {
+ thinking_delta: None,
+ text_delta: None,
+ turn_ended: Some(TurnEnded {
+ input_tokens: input,
+ output_tokens: output,
+ cache_read_tokens: 0,
+ cache_write_tokens: 0,
+ }),
+ }),
+ exec_server_message: None,
+ };
+ let mut payload = Vec::new();
+ msg.encode(&mut payload).unwrap();
+ encode_connect_frame(&payload, 0).to_vec()
+ }
+
+ fn make_end_frame() -> Vec<u8> {
+ encode_connect_frame(b"", 2).to_vec()
+ }
+
+ #[test]
+ fn sse_produces_message_start_and_stop() {
+ let mut body = Vec::new();
+ body.extend_from_slice(&make_text_frame("hello"));
+ body.extend_from_slice(&make_usage_frame(10, 5));
+ body.extend_from_slice(&make_end_frame());
+
+ let upstream = CursorUpstreamResponse {
+ status: 200,
+ body,
+ error_detail: None,
+ };
+
+ let sse = frame_cursor_stream(&upstream, "msg_1", "cursor-test");
+ let sse_str = String::from_utf8_lossy(&sse);
+
+ // Verify event structure with explicit parsing
+ let events = parse_sse_events(&sse_str);
+ let event_names: Vec<&str> = events.iter().map(|e| e.0.as_str()).collect();
+
+ assert_eq!(
+ event_names,
+ vec![
+ "message_start",
+ "content_block_start",
+ "content_block_delta",
+ "content_block_stop",
+ "message_delta",
+ "message_stop"
+ ]
+ );
+ }
+
+ #[test]
+ fn sse_includes_text_delta_content() {
+ let mut body = Vec::new();
+ body.extend_from_slice(&make_text_frame("Hello world"));
+ body.extend_from_slice(&make_usage_frame(10, 2));
+ body.extend_from_slice(&make_end_frame());
+
+ let upstream = CursorUpstreamResponse {
+ status: 200,
+ body,
+ error_detail: None,
+ };
+
+ let sse = frame_cursor_stream(&upstream, "msg_1", "cursor-test");
+ let sse_str = String::from_utf8_lossy(&sse);
+ let events = parse_sse_events(&sse_str);
+
+ // Find text_delta event
+ let text_delta = events
+ .iter()
+ .find(|(name, _)| *name == "content_block_delta")
+ .map(|(_, data)| data["delta"]["text"].as_str().unwrap_or(""));
+ assert_eq!(text_delta, Some("Hello world"));
+ }
+
+ #[test]
+ fn sse_includes_usage_in_message_delta() {
+ let mut body = Vec::new();
+ body.extend_from_slice(&make_text_frame("hi"));
+ body.extend_from_slice(&make_usage_frame(25, 7));
+ body.extend_from_slice(&make_end_frame());
+
+ let upstream = CursorUpstreamResponse {
+ status: 200,
+ body,
+ error_detail: None,
+ };
+
+ let sse = frame_cursor_stream(&upstream, "msg_1", "cursor-test");
+ let sse_str = String::from_utf8_lossy(&sse);
+ let events = parse_sse_events(&sse_str);
+
+ let msg_delta = events
+ .iter()
+ .find(|(name, _)| *name == "message_delta")
+ .map(|(_, data)| data.clone());
+ assert!(msg_delta.is_some());
+ let delta = msg_delta.unwrap();
+ assert_eq!(delta["usage"]["input_tokens"].as_u64(), Some(25));
+ assert_eq!(delta["usage"]["output_tokens"].as_u64(), Some(7));
+ assert_eq!(
+ delta["usage"]["cache_creation_input_tokens"].as_u64(),
+ Some(0)
+ );
+ assert_eq!(delta["usage"]["cache_read_input_tokens"].as_u64(), Some(0));
+ }
+
+ #[test]
+ fn sse_handles_empty_upstream() {
+ let upstream = CursorUpstreamResponse {
+ status: 200,
+ body: Vec::new(),
+ error_detail: None,
+ };
+
+ let sse = frame_cursor_stream(&upstream, "msg_1", "cursor-test");
+ let sse_str = String::from_utf8_lossy(&sse);
+
+ // Should still produce events even with empty body
+ let events = parse_sse_events(&sse_str);
+ let event_names: Vec<&str> = events.iter().map(|e| e.0.as_str()).collect();
+ assert!(event_names.contains(&"message_start"));
+ assert!(event_names.contains(&"message_stop"));
+ }
+
+ #[test]
+ fn sse_emits_thinking_before_text() {
+ // Build a response with thinking delta then text delta
+ let thinking_msg = AgentServerMessage {
+ interaction_update: Some(InteractionUpdate {
+ thinking_delta: Some(ThinkingDelta {
+ text: "thinking...".to_string(),
+ }),
+ text_delta: None,
+ turn_ended: None,
+ }),
+ exec_server_message: None,
+ };
+ let mut payload = Vec::new();
+ thinking_msg.encode(&mut payload).unwrap();
+ let mut body: Vec<u8> = encode_connect_frame(&payload, 0).to_vec();
+
+ body.extend_from_slice(&make_text_frame("result"));
+ body.extend_from_slice(&make_usage_frame(10, 5));
+ body.extend_from_slice(&make_end_frame());
+
+ let upstream = CursorUpstreamResponse {
+ status: 200,
+ body,
+ error_detail: None,
+ };
+
+ let sse = frame_cursor_stream(&upstream, "msg_1", "cursor-test");
+ let sse_str = String::from_utf8_lossy(&sse);
+ let events = parse_sse_events(&sse_str);
+ let event_names: Vec<&str> = events.iter().map(|e| e.0.as_str()).collect();
+
+ // Should have thinking content block start and delta
+ assert!(events.iter().any(|(_, data)| {
+ data.get("content_block")
+ .and_then(|c| c.get("type"))
+ .and_then(|t| t.as_str())
+ == Some("thinking")
+ }));
+
+ // Should have text content block
+ assert!(events.iter().any(|(_, data)| {
+ data.get("content_block")
+ .and_then(|c| c.get("type"))
+ .and_then(|t| t.as_str())
+ == Some("text")
+ }));
+ }
+
+ #[test]
+ fn sse_error_response() {
+ let sse = format_sse_error("something broke");
+ let sse_str = String::from_utf8_lossy(&sse);
+ let events = parse_sse_events(&sse_str);
+
+ let (name, data) = &events[0];
+ assert_eq!(name, "error");
+ assert_eq!(data["error"]["type"], "api_error");
+ assert_eq!(data["error"]["message"], "something broke");
+ }
+
+ // -----------------------------------------------------------------------
+ // SSE parser helper for tests
+ // -----------------------------------------------------------------------
+
+ pub fn parse_sse_events(sse: &str) -> Vec<(String, serde_json::Value)> {
+ let mut events = Vec::new();
+ let mut current_event = String::new();
+
+ for line in sse.lines() {
+ if line.starts_with("event: ") {
+ current_event = line["event: ".len()..].to_string();
+ } else if line.starts_with("data: ") {
+ let data_str = &line["data: ".len()..];
+ if let Ok(data) = serde_json::from_str::<serde_json::Value>(data_str) {
+ events.push((current_event.clone(), data));
+ }
+ }
+ }
+
+ events
+ }
+}
diff --git a/src/providers/mod.rs b/src/providers/mod.rs
index c186e89..c413d22 100644
--- a/src/providers/mod.rs
+++ b/src/providers/mod.rs
@@ -1,2 +1,3 @@
pub mod codex;
+pub mod cursor;
pub mod kimi;
diff --git a/src/registry.rs b/src/registry.rs
index e45dc44..be78b2a 100644
--- a/src/registry.rs
+++ b/src/registry.rs
@@ -64,6 +64,7 @@ impl Registry {
let handler: Arc<dyn Provider> = match name.as_str() {
"codex" => Arc::new(crate::providers::codex::CodexProvider::new()),
"kimi" => Arc::new(crate::providers::kimi::KimiProvider::new()),
+ "cursor" => Arc::new(crate::providers::cursor::CursorProvider::new()),
_ => Arc::new(PlaceholderProvider::new(name, entries.clone())),
};
handlers.insert(name.clone(), handler);
diff --git a/tests/cursor_native.rs b/tests/cursor_native.rs
new file mode 100644
index 0000000..de5c391
--- /dev/null
+++ b/tests/cursor_native.rs
@@ -0,0 +1,722 @@
+//! Integration tests for the Cursor native provider.
+//!
+//! These tests cover:
+//! - Prost message roundtrip
+//! - Connect frame encode/decode (with fixtures)
+//! - Auth resolution
+//! - Model catalog resolution
+//! - Prompt rendering
+//! - Client request/response boundary
+//! - SSE framing
+//! - Registry routing
+//! - Provider end-to-end against mock upstream
+
+use once_cell::sync::Lazy;
+use std::sync::Mutex;
+
+static ENV_LOCK: Lazy<Mutex<()>> = Lazy::new(|| Mutex::new(()));
+
+// ---------------------------------------------------------------------------
+// Prost roundtrip
+// ---------------------------------------------------------------------------
+
+#[test]
+fn prost_roundtrip_preserves_cursor_server_message() {
+ use claude_code_proxy::providers::cursor::proto::*;
+ use prost::Message;
+
+ let msg = AgentServerMessage {
+ interaction_update: Some(InteractionUpdate {
+ thinking_delta: None,
+ text_delta: Some(TextDelta {
+ text: "hello".into(),
+ }),
+ turn_ended: Some(TurnEnded {
+ input_tokens: 7,
+ output_tokens: 2,
+ cache_read_tokens: 0,
+ cache_write_tokens: 0,
+ }),
+ }),
+ exec_server_message: None,
+ };
+ let mut bytes = Vec::new();
+ msg.encode(&mut bytes).unwrap();
+ let decoded = AgentServerMessage::decode(bytes.as_slice()).unwrap();
+ assert_eq!(
+ decoded.interaction_update.unwrap().text_delta.unwrap().text,
+ "hello"
+ );
+}
+
+#[test]
+fn prost_roundtrip_preserves_client_message() {
+ use claude_code_proxy::providers::cursor::proto::*;
+ use prost::Message;
+
+ let msg = AgentClientMessage {
+ run_request: Some(RunRequest {
+ conversation_state: None,
+ action: Some(Action {
+ user_message_action: Some(UserMessageAction {
+ user_message: Some(UserMessage {
+ text: "hello".into(),
+ message_id: "msg-id".into(),
+ selected_context: None,
+ mode: "AGENT_MODE_AGENT".into(),
+ }),
+ }),
+ }),
+ mcp_tools: None,
+ conversation_id: String::new(),
+ requested_model: Some(CursorModel {
+ model_id: "gpt-5.5".into(),
+ parameters: vec![ModelParameter {
+ id: "context".into(),
+ value: "128k".into(),
+ }],
+ }),
+ exclude_workspace_context: false,
+ selected_subagent_models: vec![],
+ conversation_group_id: String::new(),
+ client_supports_inline_images: true,
+ }),
+ client_heartbeat: None,
+ };
+
+ let mut bytes = Vec::new();
+ msg.encode(&mut bytes).unwrap();
+ let decoded = AgentClientMessage::decode(bytes.as_slice()).unwrap();
+ let run = decoded.run_request.unwrap();
+ let action = run.action.unwrap();
+ let user_msg = action.user_message_action.unwrap().user_message.unwrap();
+ assert_eq!(user_msg.text, "hello");
+ assert_eq!(run.requested_model.unwrap().model_id, "gpt-5.5");
+}
+
+// ---------------------------------------------------------------------------
+// Connect frame fixtures
+// ---------------------------------------------------------------------------
+
+#[test]
+fn connect_frame_fixture_matches_reference_layout() {
+ use claude_code_proxy::providers::cursor::connect::encode_connect_frame;
+
+ let frame = encode_connect_frame(b"abc", 0);
+ assert_eq!(hex::encode(frame), "0000000003616263");
+}
+
+#[test]
+fn connect_frame_decode_reference() {
+ use claude_code_proxy::providers::cursor::connect::ConnectFrameDecoder;
+
+ let wire = hex::decode("0000000003616263").unwrap();
+ let mut decoder = ConnectFrameDecoder::new();
+ let frames = decoder.push(&wire).unwrap();
+ assert_eq!(frames.len(), 1);
+ assert_eq!(frames[0].flags, 0);
+ assert_eq!(&frames[0].payload[..], b"abc");
+}
+
+#[test]
+fn connect_frame_with_flags_decode() {
+ use claude_code_proxy::providers::cursor::connect::ConnectFrameDecoder;
+ use claude_code_proxy::providers::cursor::connect::encode_connect_frame;
+
+ let frame = encode_connect_frame(b"xyz", 0x03);
+ let mut decoder = ConnectFrameDecoder::new();
+ let frames = decoder.push(frame).unwrap();
+ assert_eq!(frames[0].flags, 0x03);
+}
+
+// ---------------------------------------------------------------------------
+// Auth resolution
+// ---------------------------------------------------------------------------
+
+#[test]
+fn auth_returns_token_from_env() {
+ let _guard = ENV_LOCK.lock().unwrap();
+ unsafe {
+ std::env::set_var("CCP_CURSOR_AUTH_TOKEN", "test-token-123");
+ }
+ let token = claude_code_proxy::providers::cursor::auth::load_cursor_token();
+ assert_eq!(token.as_deref(), Some("test-token-123"));
+ unsafe {
+ std::env::remove_var("CCP_CURSOR_AUTH_TOKEN");
+ }
+}
+
+// ---------------------------------------------------------------------------
+// Model catalog
+// ---------------------------------------------------------------------------
+
+#[test]
+fn model_resolution_resolves_cursor_agent_prefix() {
+ use claude_code_proxy::providers::cursor::model::*;
+
+ let r = resolve_cursor_model("cursor-agent:gpt-5.5").unwrap();
+ assert_eq!(r.model_id, "gpt-5.5");
+ assert_eq!(r.mode, CursorAgentMode::Agent);
+}
+
+#[test]
+fn model_resolution_accepts_legacy_cursor_agent() {
+ use claude_code_proxy::providers::cursor::model::*;
+
+ let r = resolve_cursor_model("cursor-agent").unwrap();
+ assert_eq!(r.mode, CursorAgentMode::Agent);
+}
+
+#[test]
+fn registry_routes_cursor_model_to_cursor_provider() {
+ use claude_code_proxy::Registry;
+ use claude_code_proxy::config::AliasProvider;
+
+ let registry = Registry::new(AliasProvider::Codex);
+ let provider = registry.provider_for_model("cursor:gpt-5.5", None);
+ assert!(provider.is_some());
+ assert_eq!(provider.unwrap().name(), "cursor");
+
+ let provider = registry.provider_for_model("cursor-agent", None);
+ assert!(provider.is_some());
+ assert_eq!(provider.unwrap().name(), "cursor");
+}
+
+// ---------------------------------------------------------------------------
+// Prompt rendering
+// ---------------------------------------------------------------------------
+
+#[test]
+fn prompt_renders_system_tools_and_messages() {
+ use claude_code_proxy::MessagesRequest;
+ use claude_code_proxy::providers::cursor::request::render_cursor_prompt;
+
+ let req: MessagesRequest = serde_json::from_value(serde_json::json!({
+ "model": "cursor:gpt-5.5",
+ "system": "be direct",
+ "messages": [{
+ "role": "user",
+ "content": [
+ {"type":"text","text":"hi"},
+ {"type":"image","source":{"type":"base64","media_type":"image/png","data":"AAAA"}}
+ ]
+ }],
+ "tools": [{"name":"Read","description":"read files","input_schema":{"type":"object"}}]
+ }))
+ .unwrap();
+
+ let rendered = render_cursor_prompt(&req);
+ assert!(rendered.contains("<system>"));
+ assert!(rendered.contains("<user>"));
+ assert!(rendered.contains("<tools>"));
+}
+
+#[test]
+fn selected_images_count_matches_base64_images() {
+ use claude_code_proxy::MessagesRequest;
+ use claude_code_proxy::providers::cursor::request::cursor_selected_images;
+
+ let req: MessagesRequest = serde_json::from_value(serde_json::json!({
+ "model": "cursor:gpt-5.5",
+ "messages": [{
+ "role": "user",
+ "content": [
+ {"type":"text","text":"analyze"},
+ {"type":"image","source":{"type":"base64","media_type":"image/png","data":"AAAA"}},
+ {"type":"image","source":{"type":"base64","media_type":"image/jpeg","data":"BBBB"}}
+ ]
+ }]
+ }))
+ .unwrap();
+
+ assert_eq!(cursor_selected_images(&req).len(), 2);
+}
+
+// ---------------------------------------------------------------------------
+// Client request/response boundary (high-level shape)
+// ---------------------------------------------------------------------------
+
+#[test]
+fn cursor_client_constructs_correct_url() {
+ use claude_code_proxy::providers::cursor::client::CursorHttpClient;
+
+ let client = CursorHttpClient::new();
+ // Just ensure construction doesn't panic
+ let _ = client;
+}
+
+#[test]
+fn cursor_error_display_works() {
+ use claude_code_proxy::providers::cursor::client::CursorError;
+
+ let err = CursorError::new(429, "rate limited", Some("backoff".to_string()));
+ let display = format!("{err}");
+ assert!(display.contains("429"));
+ assert!(display.contains("rate limited"));
+}
+
+// ---------------------------------------------------------------------------
+// Response decoding
+// ---------------------------------------------------------------------------
+
+#[test]
+fn response_decode_extracts_text_and_usage() {
+ use claude_code_proxy::providers::cursor::connect::encode_connect_frame;
+ use claude_code_proxy::providers::cursor::proto::*;
+ use claude_code_proxy::providers::cursor::response::*;
+ use prost::Message;
+
+ let mut body = Vec::new();
+
+ // Text frame
+ let msg = AgentServerMessage {
+ interaction_update: Some(InteractionUpdate {
+ thinking_delta: None,
+ text_delta: Some(TextDelta {
+ text: "Hello".into(),
+ }),
+ turn_ended: None,
+ }),
+ exec_server_message: None,
+ };
+ let mut payload = Vec::new();
+ msg.encode(&mut payload).unwrap();
+ body.extend_from_slice(&encode_connect_frame(&payload, 0));
+
+ // Usage frame
+ let msg = AgentServerMessage {
+ interaction_update: Some(InteractionUpdate {
+ thinking_delta: None,
+ text_delta: None,
+ turn_ended: Some(TurnEnded {
+ input_tokens: 10,
+ output_tokens: 5,
+ cache_read_tokens: 0,
+ cache_write_tokens: 0,
+ }),
+ }),
+ exec_server_message: None,
+ };
+ let mut payload = Vec::new();
+ msg.encode(&mut payload).unwrap();
+ body.extend_from_slice(&encode_connect_frame(&payload, 0));
+
+ // End frame
+ body.extend_from_slice(&encode_connect_frame(b"", 2));
+
+ let upstream = claude_code_proxy::providers::cursor::client::CursorUpstreamResponse {
+ status: 200,
+ body,
+ error_detail: None,
+ };
+
+ let json = decode_cursor_upstream(&upstream, "msg_test", "cursor-test").unwrap();
+ assert_eq!(json["id"], "msg_test");
+ assert_eq!(json["content"][0]["text"], "Hello");
+ assert_eq!(json["usage"]["input_tokens"].as_u64(), Some(10));
+ assert_eq!(json["usage"]["output_tokens"].as_u64(), Some(5));
+}
+
+// ---------------------------------------------------------------------------
+// SSE framing - parse event names and data
+// ---------------------------------------------------------------------------
+
+#[test]
+fn sse_parses_event_names_and_data() {
+ use claude_code_proxy::providers::cursor::connect::encode_connect_frame;
+ use claude_code_proxy::providers::cursor::proto::*;
+ use claude_code_proxy::providers::cursor::sse::frame_cursor_stream;
+ use prost::Message;
+
+ let mut body = Vec::new();
+
+ let msg = AgentServerMessage {
+ interaction_update: Some(InteractionUpdate {
+ thinking_delta: None,
+ text_delta: Some(TextDelta { text: "hi".into() }),
+ turn_ended: None,
+ }),
+ exec_server_message: None,
+ };
+ let mut payload = Vec::new();
+ msg.encode(&mut payload).unwrap();
+ body.extend_from_slice(&encode_connect_frame(&payload, 0));
+
+ let msg = AgentServerMessage {
+ interaction_update: Some(InteractionUpdate {
+ thinking_delta: None,
+ text_delta: None,
+ turn_ended: Some(TurnEnded {
+ input_tokens: 5,
+ output_tokens: 1,
+ cache_read_tokens: 0,
+ cache_write_tokens: 0,
+ }),
+ }),
+ exec_server_message: None,
+ };
+ let mut payload = Vec::new();
+ msg.encode(&mut payload).unwrap();
+ body.extend_from_slice(&encode_connect_frame(&payload, 0));
+
+ body.extend_from_slice(&encode_connect_frame(b"", 2));
+
+ let upstream = claude_code_proxy::providers::cursor::client::CursorUpstreamResponse {
+ status: 200,
+ body,
+ error_detail: None,
+ };
+
+ let sse = frame_cursor_stream(&upstream, "msg_sse", "cursor-test");
+ let sse_str = String::from_utf8_lossy(&sse);
+
+ let events = parse_sse_events(&sse_str);
+ let names: Vec<&str> = events.iter().map(|(n, _)| n.as_str()).collect();
+ assert!(
+ names.contains(&"message_start"),
+ "expected message_start in {names:?}"
+ );
+ assert!(
+ names.contains(&"content_block_delta"),
+ "expected content_block_delta in {names:?}"
+ );
+ assert!(
+ names.contains(&"message_delta"),
+ "expected message_delta in {names:?}"
+ );
+ assert!(
+ names.contains(&"message_stop"),
+ "expected message_stop in {names:?}"
+ );
+}
+
+#[test]
+fn sse_message_delta_contains_usage() {
+ use claude_code_proxy::providers::cursor::connect::encode_connect_frame;
+ use claude_code_proxy::providers::cursor::proto::*;
+ use claude_code_proxy::providers::cursor::sse::frame_cursor_stream;
+ use prost::Message;
+
+ let mut body = Vec::new();
+
+ let msg = AgentServerMessage {
+ interaction_update: Some(InteractionUpdate {
+ thinking_delta: None,
+ text_delta: Some(TextDelta {
+ text: "test".into(),
+ }),
+ turn_ended: Some(TurnEnded {
+ input_tokens: 42,
+ output_tokens: 7,
+ cache_read_tokens: 0,
+ cache_write_tokens: 0,
+ }),
+ }),
+ exec_server_message: None,
+ };
+ let mut payload = Vec::new();
+ msg.encode(&mut payload).unwrap();
+ body.extend_from_slice(&encode_connect_frame(&payload, 0));
+ body.extend_from_slice(&encode_connect_frame(b"", 2));
+
+ let upstream = claude_code_proxy::providers::cursor::client::CursorUpstreamResponse {
+ status: 200,
+ body,
+ error_detail: None,
+ };
+
+ let sse = frame_cursor_stream(&upstream, "msg_u", "cursor-test");
+ let sse_str = String::from_utf8_lossy(&sse);
+ let events = parse_sse_events(&sse_str);
+
+ let msg_delta_data = events
+ .iter()
+ .find(|(n, _)| n == "message_delta")
+ .map(|(_, d)| d.clone());
+ assert!(msg_delta_data.is_some(), "expected message_delta event");
+ let data = msg_delta_data.unwrap();
+ assert_eq!(data["usage"]["input_tokens"].as_u64(), Some(42));
+ assert_eq!(data["usage"]["output_tokens"].as_u64(), Some(7));
+ assert_eq!(
+ data["usage"]["cache_creation_input_tokens"].as_u64(),
+ Some(0)
+ );
+ assert_eq!(data["usage"]["cache_read_input_tokens"].as_u64(), Some(0));
+ assert_eq!(data["delta"]["stop_reason"], "end_turn");
+}
+
+// ---------------------------------------------------------------------------
+// Registry integration
+// ---------------------------------------------------------------------------
+
+#[test]
+fn registry_provider_for_legacy_cursor_model() {
+ use claude_code_proxy::Registry;
+ use claude_code_proxy::config::AliasProvider;
+
+ let registry = Registry::new(AliasProvider::Codex);
+
+ // Legacy models
+ for model in &[
+ "cursor",
+ "cursor-agent",
+ "cursor-composer",
+ "cursor-composer-fast",
+ "cursor-plan",
+ "cursor-ask",
+ ] {
+ let provider = registry.provider_for_model(model, None);
+ assert!(
+ provider.is_some(),
+ "expected provider for legacy model {model}"
+ );
+ assert_eq!(
+ provider.unwrap().name(),
+ "cursor",
+ "model {model} should route to cursor provider"
+ );
+ }
+}
+
+// ---------------------------------------------------------------------------
+// Mock upstream streaming test (full integration)
+// ---------------------------------------------------------------------------
+
+#[tokio::test]
+async fn cursor_provider_streams_text_and_usage_from_mock_upstream() {
+ use axum::{Router, routing::post};
+ use claude_code_proxy::providers::cursor::connect::encode_connect_frame;
+ use claude_code_proxy::providers::cursor::proto::*;
+ use claude_code_proxy::providers::cursor::response::decode_cursor_upstream;
+ use claude_code_proxy::providers::cursor::sse::frame_cursor_stream;
+ use prost::Message;
+
+ let _guard = ENV_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+
+ // Build mock upstream response bytes
+ let mut body = Vec::new();
+
+ let msg = AgentServerMessage {
+ interaction_update: Some(InteractionUpdate {
+ thinking_delta: None,
+ text_delta: Some(TextDelta {
+ text: "Hello from mock".into(),
+ }),
+ turn_ended: None,
+ }),
+ exec_server_message: None,
+ };
+ let mut payload = Vec::new();
+ msg.encode(&mut payload).unwrap();
+ body.extend_from_slice(&encode_connect_frame(&payload, 0));
+
+ let msg = AgentServerMessage {
+ interaction_update: Some(InteractionUpdate {
+ thinking_delta: None,
+ text_delta: None,
+ turn_ended: Some(TurnEnded {
+ input_tokens: 15,
+ output_tokens: 3,
+ cache_read_tokens: 0,
+ cache_write_tokens: 0,
+ }),
+ }),
+ exec_server_message: None,
+ };
+ let mut payload = Vec::new();
+ msg.encode(&mut payload).unwrap();
+ body.extend_from_slice(&encode_connect_frame(&payload, 0));
+
+ body.extend_from_slice(&encode_connect_frame(b"", 2));
+
+ let response_body = body.clone();
+
+ let app = Router::new().route(
+ "/agent.v1.AgentService/Run",
+ post(move |_body: axum::body::Bytes| async move {
+ (
+ [(
+ axum::http::header::CONTENT_TYPE,
+ "application/connect+proto",
+ )],
+ response_body,
+ )
+ }),
+ );
+
+ let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+ let addr = listener.local_addr().unwrap();
+ let mock_url = format!("http://{}", addr);
+
+ unsafe {
+ std::env::set_var("CCP_CURSOR_BASE_URL", &mock_url);
+ std::env::set_var("CCP_CURSOR_AUTH_TOKEN", "mock-token");
+ std::env::set_var("CCP_CURSOR_CLIENT_VERSION", "0.0.0");
+ }
+
+ let _handle = tokio::spawn(async move {
+ axum::serve(listener, app).await.unwrap();
+ });
+
+ tokio::time::sleep(std::time::Duration::from_millis(50)).await;
+
+ use claude_code_proxy::providers::cursor::auth::load_cursor_token;
+ use claude_code_proxy::providers::cursor::client::CursorHttpClient;
+
+ let token = load_cursor_token().unwrap();
+ let client = CursorHttpClient::new();
+ let upstream = client
+ .run_agent(&token, "test prompt", "cursor:gpt-5.5", &[])
+ .await
+ .expect("mock upstream request should succeed");
+
+ assert!(upstream.is_success());
+ assert_eq!(upstream.status, 200);
+
+ let json = decode_cursor_upstream(&upstream, "msg_mock", "cursor-test").unwrap();
+ assert_eq!(json["content"][0]["text"], "Hello from mock");
+ assert_eq!(json["usage"]["input_tokens"].as_u64(), Some(15));
+ assert_eq!(json["usage"]["output_tokens"].as_u64(), Some(3));
+
+ let sse = frame_cursor_stream(&upstream, "msg_sse_mock", "cursor-test");
+ let sse_str = String::from_utf8_lossy(&sse);
+ let events = parse_sse_events(&sse_str);
+ let names: Vec<&str> = events.iter().map(|(n, _)| n.as_str()).collect();
+
+ assert!(
+ names.contains(&"message_start"),
+ "SSE should include message_start in {names:?}"
+ );
+ assert!(
+ names.contains(&"message_stop"),
+ "SSE should include message_stop in {names:?}"
+ );
+
+ unsafe {
+ std::env::remove_var("CCP_CURSOR_BASE_URL");
+ std::env::remove_var("CCP_CURSOR_AUTH_TOKEN");
+ std::env::remove_var("CCP_CURSOR_CLIENT_VERSION");
+ }
+}
+
+// ---------------------------------------------------------------------------
+// Provider handle_messages shape test (non-streaming)
+// ---------------------------------------------------------------------------
+
+#[tokio::test]
+async fn cursor_provider_handle_messages_returns_anthropic_json() {
+ use axum::{Router, routing::post};
+ use claude_code_proxy::providers::cursor::connect::encode_connect_frame;
+ use claude_code_proxy::providers::cursor::proto::*;
+ use prost::Message;
+
+ let _guard = ENV_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+
+ // Build mock response
+ let mut body = Vec::new();
+ let msg = AgentServerMessage {
+ interaction_update: Some(InteractionUpdate {
+ thinking_delta: None,
+ text_delta: Some(TextDelta {
+ text: "Mock response text".into(),
+ }),
+ turn_ended: Some(TurnEnded {
+ input_tokens: 20,
+ output_tokens: 4,
+ cache_read_tokens: 0,
+ cache_write_tokens: 0,
+ }),
+ }),
+ exec_server_message: None,
+ };
+ let mut payload = Vec::new();
+ msg.encode(&mut payload).unwrap();
+ body.extend_from_slice(&encode_connect_frame(&payload, 0));
+ body.extend_from_slice(&encode_connect_frame(b"", 2));
+
+ let response_body = body;
+
+ let app = Router::new().route(
+ "/agent.v1.AgentService/Run",
+ post(move |_body: axum::body::Bytes| async move {
+ (
+ [(
+ axum::http::header::CONTENT_TYPE,
+ "application/connect+proto",
+ )],
+ response_body,
+ )
+ }),
+ );
+
+ let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+ let addr = listener.local_addr().unwrap();
+ let mock_url = format!("http://{}", addr);
+
+ unsafe {
+ std::env::set_var("CCP_CURSOR_BASE_URL", &mock_url);
+ std::env::set_var("CCP_CURSOR_AUTH_TOKEN", "mock-token-handler");
+ std::env::set_var("CCP_CURSOR_CLIENT_VERSION", "0.0.0");
+ }
+
+ let _handle = tokio::spawn(async move {
+ axum::serve(listener, app).await.unwrap();
+ });
+
+ tokio::time::sleep(std::time::Duration::from_millis(50)).await;
+
+ // Send via handle_messages (non-streaming)
+ use claude_code_proxy::provider::Provider;
+ use claude_code_proxy::provider::RequestContext;
+ use claude_code_proxy::providers::cursor::CursorProvider;
+
+ let provider = CursorProvider::new();
+ let body = serde_json::from_value(serde_json::json!({
+ "model": "cursor:gpt-5.5",
+ "messages": [{"role": "user", "content": "test"}]
+ }))
+ .unwrap();
+
+ let ctx = RequestContext {
+ req_id: "test-req".into(),
+ session_id: None,
+ session_seq: None,
+ provider: "cursor".into(),
+ };
+
+ let response = provider.handle_messages(body, ctx).await;
+ // Should not return an error response
+ let status = response.status();
+ assert!(
+ status != 401 && status != 400,
+ "handle_messages returned error status {status}"
+ );
+
+ unsafe {
+ std::env::remove_var("CCP_CURSOR_BASE_URL");
+ std::env::remove_var("CCP_CURSOR_AUTH_TOKEN");
+ std::env::remove_var("CCP_CURSOR_CLIENT_VERSION");
+ }
+}
+
+// ---------------------------------------------------------------------------
+// SSE parser helper (mirrors sse.rs internal helper for cross-module access)
+// ---------------------------------------------------------------------------
+
+fn parse_sse_events(sse: &str) -> Vec<(String, serde_json::Value)> {
+ let mut events = Vec::new();
+ let mut current_event = String::new();
+
+ for line in sse.lines() {
+ if line.starts_with("event: ") {
+ current_event = line["event: ".len()..].to_string();
+ } else if line.starts_with("data: ") {
+ let data_str = &line["data: ".len()..];
+ if let Ok(data) = serde_json::from_str::<serde_json::Value>(data_str) {
+ events.push((current_event.clone(), data));
+ }
+ }
+ }
+
+ events
+}