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.lockindex 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.tomlindex 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.rsindex 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsindex 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.rsindex 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.rsnew file mode 100644index 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+}