Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy
Rust
fix current Cursor agent protocol
Raine Virta4ad7dfe0a498
diff --git a/src/config.rs b/src/config.rsindex 595d75f..ad31b33 100644--- a/src/config.rs+++ b/src/config.rs@@ -666,7 +666,27 @@ pub fn cursor_client_version() -> String {{return version;}- "0.48.5".to_string()+ detect_cursor_agent_version().unwrap_or_else(|| "cli-2026.07.23-e383d2b".to_string())+}++fn detect_cursor_agent_version() -> Option<String> {+ let output = std::process::Command::new("cursor-agent")+ .arg("--version")+ .output()+ .ok()?;+ if !output.status.success() {+ return None;+ }+ let version = String::from_utf8(output.stdout).ok()?;+ let version = version.lines().next()?.trim();+ if version.is_empty() {+ return None;+ }+ Some(if version.starts_with("cli-") {+ version.to_string()+ } else {+ format!("cli-{version}")+ })}pub fn cursor_agent_bundle() -> Option<String> {diff --git a/src/providers/cursor/client.rs b/src/providers/cursor/client.rsindex 22f8bda..79d784f 100644--- a/src/providers/cursor/client.rs+++ b/src/providers/cursor/client.rs@@ -1,4 +1,8 @@+use base64::Engine;+use bytes::Bytes;+use futures_util::StreamExt;use prost::Message;+use tokio::sync::mpsc;use crate::config;use crate::providers::cursor::connect::{@@ -6,7 +10,7 @@ use crate::providers::cursor::connect::{parse_connect_error,};use crate::providers::cursor::model::CursorModelResolution;-use crate::providers::cursor::proto::{self, AgentClientMessage, RunRequest};+use crate::providers::cursor::proto;use crate::providers::cursor::request::CursorSelectedImage;/// Upstream response from the Cursor API.@@ -59,8 +63,8 @@ impl CursorHttpClient {/// 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.+ /// Opens a bidirectional Connect stream, sends the agent request frames,+ /// and keeps the request body alive while collecting the response frames.pub async fn run_agent(&self,token: &str,@@ -72,35 +76,49 @@ impl CursorHttpClient {.map_err(|e| CursorError::internal(format!("model resolution: {e}")))?;let request_id = uuid::Uuid::new_v4().to_string();+ let frames = build_run_frames(prompt, &resolved, images, &request_id);+ let (tx, rx) = mpsc::channel::<Result<Bytes, std::io::Error>>(8);+ let sender = tokio::spawn(async move {+ for (index, frame) in frames.into_iter().enumerate() {+ if tx.send(Ok(frame)).await.is_err() {+ return;+ }+ let delay = match index {+ 0 => std::time::Duration::from_millis(1500),+ 1 => std::time::Duration::from_millis(800),+ _ => std::time::Duration::from_millis(400),+ };+ tokio::time::sleep(delay).await;+ }- // 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 mut heartbeat = tokio::time::interval(std::time::Duration::from_secs(5));+ heartbeat.tick().await;+ loop {+ heartbeat.tick().await;+ if tx.send(Ok(heartbeat_frame())).await.is_err() {+ return;+ }+ }+ });+ let body =+ reqwest::Body::wrap_stream(futures_util::stream::unfold(rx, |mut rx| async move {+ rx.recv().await.map(|item| (item, rx))+ }));let url = format!("{}/agent.v1.AgentService/Run",self.base_url.trim_end_matches('/'));-let client_version = config::cursor_client_version();- let resp = self+ let response = 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("user-agent", "connect-es/1.6.1").header("x-cursor-client-type", "cli").header("x-cursor-client-version", &client_version).header("x-ghost-mode", "true")@@ -113,78 +131,221 @@ impl CursorHttpClient {.await.map_err(CursorError::from_reqwest)?;- let status = resp.status().as_u16();- let headers = resp.headers().clone();- let error_detail = resp+ let status = response.status().as_u16();+ let headers = response.headers().clone();+ let error_detail = response.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}")))?;+ .and_then(|value| value.to_str().ok())+ .map(str::to_string);+ let mut stream = response.bytes_stream();+ let mut body_bytes = Vec::new();+ let mut received_data = false;++ loop {+ let timeout = if received_data {+ std::time::Duration::from_secs(5)+ } else {+ std::time::Duration::from_secs(60)+ };+ match tokio::time::timeout(timeout, stream.next()).await {+ Ok(Some(Ok(chunk))) => {+ received_data = true;+ body_bytes.extend_from_slice(&chunk);+ if contains_end_frame(&body_bytes) {+ break;+ }+ }+ Ok(Some(Err(error))) => {+ sender.abort();+ return Err(CursorError::internal(format!("read body: {error}")));+ }+ Ok(None) => break,+ Err(_) if received_data => break,+ Err(_) => {+ sender.abort();+ return Err(CursorError::internal(+ "Cursor upstream timed out before sending a response",+ ));+ }+ }+ }+ sender.abort();if status >= 400 {- // Try to extract Connect error from bodylet detail = parse_error_body(&body_bytes, &headers);return Err(CursorError::new(status, "Cursor upstream error", detail));}Ok(CursorUpstreamResponse {status,- body: body_bytes.to_vec(),+ body: body_bytes,error_detail,})}}-fn build_run_request(+fn encode_varint(mut value: u64, out: &mut Vec<u8>) {+ while value >= 0x80 {+ out.push(((value as u8) & 0x7f) | 0x80);+ value >>= 7;+ }+ out.push(value as u8);+}++fn field_bytes(field: u64, value: &[u8]) -> Vec<u8> {+ let mut out = Vec::with_capacity(value.len() + 4);+ encode_varint((field << 3) | 2, &mut out);+ encode_varint(value.len() as u64, &mut out);+ out.extend_from_slice(value);+ out+}++fn field_string(field: u64, value: &str) -> Vec<u8> {+ field_bytes(field, value.as_bytes())+}++fn field_varint(field: u64, value: u64) -> Vec<u8> {+ let mut out = Vec::new();+ encode_varint(field << 3, &mut out);+ encode_varint(value, &mut out);+ out+}++fn model_message(model: &str, fast: bool) -> Vec<u8> {+ let mut out = field_string(1, model);+ let mut parameter = field_string(1, "fast");+ parameter.extend(field_string(2, if fast { "true" } else { "false" }));+ out.extend(field_bytes(3, ¶meter));+ out+}++fn mode_value(resolved: &CursorModelResolution) -> u64 {+ match resolved.mode {+ super::model::CursorAgentMode::Agent => 1,+ super::model::CursorAgentMode::Ask => 2,+ super::model::CursorAgentMode::Plan => 3,+ }+}++fn selected_context(images: &[CursorSelectedImage]) -> Option<Vec<u8>> {+ if images.is_empty() {+ return None;+ }++ let mut context = Vec::new();+ for image in images {+ let data = base64::engine::general_purpose::STANDARD+ .decode(&image.data)+ .unwrap_or_default();+ let mut selected = field_string(2, &image.uuid);+ selected.extend(field_string(3, &image.path));+ selected.extend(field_string(7, &image.mime_type));+ selected.extend(field_bytes(8, &data));+ context.extend(field_bytes(1, &selected));+ }+ Some(context)+}++fn build_run_frames(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,+) -> Vec<Bytes> {+ let conversation_id = uuid::Uuid::new_v4().to_string();+ let mut user_message = field_string(1, prompt);+ user_message.extend(field_string(2, request_id));+ if let Some(context) = selected_context(images) {+ user_message.extend(field_bytes(3, &context));+ } else {+ user_message.extend(field_bytes(3, &[]));+ }+ user_message.extend(field_varint(4, mode_value(resolved)));++ let action = field_bytes(1, &field_bytes(1, &user_message));+ let mut request = field_bytes(1, &[]);+ request.extend(field_bytes(2, &action));+ request.extend(field_bytes(4, &[]));+ request.extend(field_string(5, &conversation_id));+ request.extend(field_bytes(+ 9,+ &model_message(&resolved.model_id, resolved.fast),+ ));+ request.extend(field_varint(12, 0));+ request.extend(field_bytes(14, &field_string(1, "default")));+ request.extend(field_bytes(+ 14,+ &model_message(&resolved.model_id, resolved.fast),+ ));+ request.extend(field_string(16, &conversation_id));+ let first = encode_connect_frame(field_bytes(1, &request), 0);++ let cwd = std::env::current_dir()+ .ok()+ .and_then(|path| path.to_str().map(str::to_string))+ .unwrap_or_default();+ let mut environment = field_string(1, std::env::consts::OS);+ environment.extend(field_string(2, &cwd));+ environment.extend(field_string(+ 3,+ if cfg!(windows) { "powershell" } else { "bash" },+ ));+ environment.extend(field_string(10, "UTC"));+ environment.extend(field_string(11, &cwd));+ environment.extend(field_varint(14, 1));+ environment.extend(field_varint(16, 1));+ environment.extend(field_varint(19, 0));+ environment.extend(field_varint(20, 0));+ environment.extend(field_string(21, &cwd));+ environment.extend(field_varint(22, 0));+ let context = field_bytes(+ 2,+ &field_bytes(+ 10,+ &field_bytes(1, &field_bytes(1, &field_bytes(4, &environment))),+ ),+ );++ let mut frames = vec![first, encode_connect_frame(context, 0)];+ frames.push(encode_connect_frame(+ field_bytes(5, &field_string(1, "")),+ 0,+ ));+ frames.push(encode_connect_frame(+ field_bytes(3, &field_string(3, "")),+ 0,+ ));+ for sequence in 1..=8 {+ let mut marker = field_varint(1, sequence);+ marker.extend(field_string(3, ""));+ frames.push(encode_connect_frame(field_bytes(3, &marker), 0));+ }+ frames+}++fn heartbeat_frame() -> Bytes {+ encode_connect_frame(field_bytes(7, &[]), 0)+}++fn contains_end_frame(body: &[u8]) -> bool {+ let mut offset = 0;+ while body.len().saturating_sub(offset) >= 5 {+ let length = u32::from_be_bytes([+ body[offset + 1],+ body[offset + 2],+ body[offset + 3],+ body[offset + 4],+ ]) as usize;+ if body.len().saturating_sub(offset) < 5 + length {+ return false;+ }+ if body[offset] & FLAG_END != 0 {+ return true;+ }+ offset += 5 + length;}+ false}fn parse_error_body(body_bytes: &[u8], _headers: &reqwest::header::HeaderMap) -> Option<String> {diff --git a/src/providers/cursor/model.rs b/src/providers/cursor/model.rsindex 36e056e..54a1224 100644--- a/src/providers/cursor/model.rs+++ b/src/providers/cursor/model.rs@@ -1,12 +1,4 @@-/// Cursor model catalog -- resolves incoming model names to Cursor model IDs.-///-/// Resolution rules:-/// - `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.+/// Cursor model catalog resolves incoming model names to Cursor wire IDs.pub const CURSOR_LEGACY_MODELS: &[&str] = &["cursor","cursor-agent",@@ -18,7 +10,6 @@ pub const CURSOR_LEGACY_MODELS: &[&str] = &["composer-2.5-fast",];-/// Agent mode derived from model prefix or name.#[derive(Debug, Clone, Copy, PartialEq, Eq)]pub enum CursorAgentMode {Agent,@@ -36,71 +27,62 @@ impl CursorAgentMode {}}-/// Resolve a model string into a (model_id, mode) pair.-///-/// Returns an error if the model is not recognized.+fn resolve_wire_model(raw: &str) -> (String, bool) {+ raw.strip_suffix("-fast")+ .map(|model| (model.to_string(), true))+ .unwrap_or_else(|| (raw.to_string(), false))+}+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,- });+ for (prefix, mode) in [+ ("cursor-agent:", CursorAgentMode::Agent),+ ("cursor-plan:", CursorAgentMode::Plan),+ ("cursor-ask:", CursorAgentMode::Ask),+ ("cursor:", CursorAgentMode::Agent),+ ] {+ if let Some(raw) = model.strip_prefix(prefix) {+ let (model_id, fast) = resolve_wire_model(raw);+ return Ok(CursorModelResolution {+ model_id,+ mode,+ fast,+ });+ }}- // Legacy exact names- match model {- "cursor" | "cursor-agent" | "cursor-composer" | "cursor-composer-fast" => {- Ok(CursorModelResolution {- model_id: model.to_string(),- mode: CursorAgentMode::Agent,- })+ let (model_id, mode, fast) = match model {+ "cursor" | "cursor-agent" => ("default", CursorAgentMode::Agent, false),+ "cursor-plan" => ("default", CursorAgentMode::Plan, false),+ "cursor-ask" => ("default", CursorAgentMode::Ask, false),+ "cursor-composer" | "composer-2.5" => ("composer-2.5", CursorAgentMode::Agent, false),+ "cursor-composer-fast" | "composer-2.5-fast" => {+ ("composer-2.5", CursorAgentMode::Agent, true)}- "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"- )),- }+ _ => {+ return Err(format!(+ "unknown cursor model: {model}. Supported: cursor:<id>, cursor-plan:<id>, cursor-ask:<id>, cursor-agent"+ ));+ }+ };+ Ok(CursorModelResolution {+ model_id: model_id.to_string(),+ mode,+ fast,+ })}#[derive(Debug, Clone)]pub struct CursorModelResolution {pub model_id: String,pub mode: CursorAgentMode,+ pub fast: bool,}-/// 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())+ .map(|model| (*model).to_string()).collect();out.sort_unstable();out@@ -112,77 +94,83 @@ mod tests {#[test]fn resolve_legacy_cursor() {- let r = resolve_cursor_model("cursor").unwrap();- assert_eq!(r.model_id, "cursor");- assert_eq!(r.mode, CursorAgentMode::Agent);+ let resolution = resolve_cursor_model("cursor").unwrap();+ assert_eq!(resolution.model_id, "default");+ assert_eq!(resolution.mode, CursorAgentMode::Agent);}#[test]fn resolve_legacy_cursor_agent() {- let r = resolve_cursor_model("cursor-agent").unwrap();- assert_eq!(r.mode, CursorAgentMode::Agent);+ let resolution = resolve_cursor_model("cursor-agent").unwrap();+ assert_eq!(resolution.model_id, "default");+ assert_eq!(resolution.mode, CursorAgentMode::Agent);}#[test]fn resolve_legacy_cursor_plan() {- let r = resolve_cursor_model("cursor-plan").unwrap();- assert_eq!(r.mode, CursorAgentMode::Plan);+ let resolution = resolve_cursor_model("cursor-plan").unwrap();+ assert_eq!(resolution.model_id, "default");+ assert_eq!(resolution.mode, CursorAgentMode::Plan);}#[test]fn resolve_legacy_cursor_ask() {- let r = resolve_cursor_model("cursor-ask").unwrap();- assert_eq!(r.mode, CursorAgentMode::Ask);+ let resolution = resolve_cursor_model("cursor-ask").unwrap();+ assert_eq!(resolution.model_id, "default");+ assert_eq!(resolution.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);+ let resolution = resolve_cursor_model("cursor:gpt-5.5").unwrap();+ assert_eq!(resolution.model_id, "gpt-5.5");+ assert_eq!(resolution.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);+ let resolution = resolve_cursor_model("cursor-plan:gpt-5.5").unwrap();+ assert_eq!(resolution.model_id, "gpt-5.5");+ assert_eq!(resolution.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);+ let resolution = resolve_cursor_model("cursor-ask:gpt-5.5").unwrap();+ assert_eq!(resolution.model_id, "gpt-5.5");+ assert_eq!(resolution.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);+ let resolution = resolve_cursor_model("cursor-agent:gpt-5.5").unwrap();+ assert_eq!(resolution.model_id, "gpt-5.5");+ assert_eq!(resolution.mode, CursorAgentMode::Agent);}#[test]fn resolve_unknown_model_errors() {- let r = resolve_cursor_model("unknown-model");- assert!(r.is_err());+ assert!(resolve_cursor_model("unknown-model").is_err());}#[test]fn resolve_composer_models() {- let r = resolve_cursor_model("composer-2.5").unwrap();- assert_eq!(r.mode, CursorAgentMode::Plan);+ let regular = resolve_cursor_model("composer-2.5").unwrap();+ assert_eq!(regular.mode, CursorAgentMode::Agent);+ assert_eq!(regular.model_id, "composer-2.5");+ assert!(!regular.fast);- let r = resolve_cursor_model("composer-2.5-fast").unwrap();- assert_eq!(r.mode, CursorAgentMode::Ask);+ let fast = resolve_cursor_model("composer-2.5-fast").unwrap();+ assert_eq!(fast.mode, CursorAgentMode::Agent);+ assert_eq!(fast.model_id, "composer-2.5");+ assert!(fast.fast);}#[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}");+ for model in CURSOR_LEGACY_MODELS {+ assert!(models.contains(&model.to_string()), "missing {model}");}}}diff --git a/src/providers/cursor/response.rs b/src/providers/cursor/response.rsindex 2584b17..c4067af 100644--- a/src/providers/cursor/response.rs+++ b/src/providers/cursor/response.rs@@ -73,8 +73,20 @@ pub fn decode_upstream_response(body: &[u8]) -> Result<Vec<CursorStreamEvent>, Ccontinue;}+ let decompressed;+ let payload = if frame.flags & crate::providers::cursor::connect::FLAG_GZIP != 0 {+ decompressed = crate::providers::cursor::connect::decode_gzip_frame(&frame.payload)+ .map_err(|error| CursorDecodeError::Decode(format!("gzip decompress: {error}")))?;+ &decompressed[..]+ } else {+ &frame.payload[..]+ };+ if events_from_current_payload(payload, &mut events) {+ continue;+ }+let msg = match decode_frame_payload(frame) {- Ok(m) => m,+ Ok(message) => message,Err(_) => continue,};@@ -139,6 +151,133 @@ fn estimate_input_tokens(_content: &str) -> u64 {(_content.len() / 4) as u64}+struct ProtoField<'a> {+ number: u64,+ wire_type: u8,+ data: &'a [u8],+ value: u64,+}++fn read_varint(bytes: &[u8]) -> Option<(u64, &[u8])> {+ let mut value = 0u64;+ let mut shift = 0;+ for (index, byte) in bytes.iter().copied().enumerate() {+ value |= u64::from(byte & 0x7f) << shift;+ if byte & 0x80 == 0 {+ return Some((value, &bytes[index + 1..]));+ }+ shift += 7;+ if shift >= 64 {+ return None;+ }+ }+ None+}++fn proto_fields(mut bytes: &[u8]) -> impl Iterator<Item = ProtoField<'_>> {+ std::iter::from_fn(move || {+ let (tag, rest) = read_varint(bytes)?;+ bytes = rest;+ let number = tag >> 3;+ let wire_type = (tag & 7) as u8;+ match wire_type {+ 0 => {+ let (value, rest) = read_varint(bytes)?;+ bytes = rest;+ Some(ProtoField {+ number,+ wire_type,+ data: &[],+ value,+ })+ }+ 1 if bytes.len() >= 8 => {+ bytes = &bytes[8..];+ Some(ProtoField {+ number,+ wire_type,+ data: &[],+ value: 0,+ })+ }+ 2 => {+ let (length, rest) = read_varint(bytes)?;+ let length = usize::try_from(length).ok()?;+ if rest.len() < length {+ return None;+ }+ let data = &rest[..length];+ bytes = &rest[length..];+ Some(ProtoField {+ number,+ wire_type,+ data,+ value: 0,+ })+ }+ 5 if bytes.len() >= 4 => {+ bytes = &bytes[4..];+ Some(ProtoField {+ number,+ wire_type,+ data: &[],+ value: 0,+ })+ }+ _ => None,+ }+ })+}++fn nested_text(payload: &[u8], update_type: u64) -> Option<String> {+ let interaction =+ proto_fields(payload).find(|field| field.number == 1 && field.wire_type == 2)?;+ let update = proto_fields(interaction.data)+ .find(|field| field.number == update_type && field.wire_type == 2)?;+ let text = proto_fields(update.data).find(|field| field.number == 1 && field.wire_type == 2)?;+ let text = std::str::from_utf8(text.data).ok()?;+ (!text.is_empty()).then(|| text.to_string())+}++fn current_usage(payload: &[u8]) -> Option<(u64, u64, u64, u64)> {+ let interaction =+ proto_fields(payload).find(|field| field.number == 1 && field.wire_type == 2)?;+ let ended =+ proto_fields(interaction.data).find(|field| field.number == 14 && field.wire_type == 2)?;+ let mut usage = [0; 4];+ for field in proto_fields(ended.data) {+ if field.wire_type == 0 && (1..=4).contains(&field.number) {+ usage[field.number as usize - 1] = field.value;+ }+ }+ Some((usage[0], usage[1], usage[2], usage[3]))+}++fn events_from_current_payload(payload: &[u8], events: &mut Vec<CursorStreamEvent>) -> bool {+ let mut decoded = false;+ if let Some(text) = nested_text(payload, 4) {+ events.push(CursorStreamEvent::ThinkingDelta { text });+ decoded = true;+ }+ if let Some(text) = nested_text(payload, 1) {+ events.push(CursorStreamEvent::TextDelta { text });+ decoded = true;+ }+ if let Some((input_tokens, output_tokens, cache_read_tokens, cache_write_tokens)) =+ current_usage(payload)+ {+ events.push(CursorStreamEvent::Usage {+ input_tokens,+ output_tokens,+ cache_read_tokens,+ cache_write_tokens,+ });+ events.push(CursorStreamEvent::End);+ decoded = true;+ }+ decoded+}+fn events_from_message(msg: &AgentServerMessage, events: &mut Vec<CursorStreamEvent>) {// Check for exec_server_message with session infoif let Some(ref exec) = msg.exec_server_messagediff --git a/src/providers/cursor/test_frames.rs b/src/providers/cursor/test_frames.rsindex eb5649b..1a75368 100644--- a/src/providers/cursor/test_frames.rs+++ b/src/providers/cursor/test_frames.rs@@ -1,32 +1,39 @@-use prost::Message;-use super::connect::encode_connect_frame;-use super::proto::{AgentServerMessage, InteractionUpdate, TextDelta, ThinkingDelta, TurnEnded};++fn varint(mut value: u64) -> Vec<u8> {+ let mut out = Vec::new();+ while value >= 0x80 {+ out.push(((value as u8) & 0x7f) | 0x80);+ value >>= 7;+ }+ out.push(value as u8);+ out+}++fn bytes_field(field: u64, value: &[u8]) -> Vec<u8> {+ let mut out = varint((field << 3) | 2);+ out.extend(varint(value.len() as u64));+ out.extend(value);+ out+}++fn varint_field(field: u64, value: u64) -> Vec<u8> {+ let mut out = varint(field << 3);+ out.extend(varint(value));+ out+}++fn interaction_frame(update_field: u64, payload: &[u8]) -> Vec<u8> {+ let update = bytes_field(update_field, payload);+ encode_connect_frame(bytes_field(1, &update), 0).to_vec()+}pub(crate) fn text_frame(text: &str) -> Vec<u8> {- encode_agent_message(AgentServerMessage {- interaction_update: Some(InteractionUpdate {- thinking_delta: None,- text_delta: Some(TextDelta {- text: text.to_string(),- }),- turn_ended: None,- }),- exec_server_message: None,- })+ interaction_frame(1, &bytes_field(1, text.as_bytes()))}pub(crate) fn thinking_frame(text: &str) -> Vec<u8> {- encode_agent_message(AgentServerMessage {- interaction_update: Some(InteractionUpdate {- thinking_delta: Some(ThinkingDelta {- text: text.to_string(),- }),- text_delta: None,- turn_ended: None,- }),- exec_server_message: None,- })+ interaction_frame(4, &bytes_field(1, text.as_bytes()))}pub(crate) fn usage_frame(input: u64, output: u64) -> Vec<u8> {@@ -39,27 +46,13 @@ pub(crate) fn usage_frame_full(cache_read: u64,cache_write: u64,) -> Vec<u8> {- encode_agent_message(AgentServerMessage {- interaction_update: Some(InteractionUpdate {- thinking_delta: None,- text_delta: None,- turn_ended: Some(TurnEnded {- input_tokens: input,- output_tokens: output,- cache_read_tokens: cache_read,- cache_write_tokens: cache_write,- }),- }),- exec_server_message: None,- })+ let mut usage = varint_field(1, input);+ usage.extend(varint_field(2, output));+ usage.extend(varint_field(3, cache_read));+ usage.extend(varint_field(4, cache_write));+ interaction_frame(14, &usage)}pub(crate) fn end_frame() -> Vec<u8> {encode_connect_frame(b"", 2).to_vec()}--fn encode_agent_message(msg: AgentServerMessage) -> Vec<u8> {- let mut payload = Vec::new();- msg.encode(&mut payload).unwrap();- encode_connect_frame(&payload, 0).to_vec()-}diff --git a/tests/cursor_native.rs b/tests/cursor_native.rsindex 6479f74..57aed4d 100644--- a/tests/cursor_native.rs+++ b/tests/cursor_native.rs@@ -11,6 +11,7 @@//! - Registry routing//! - Provider end-to-end against mock upstream+use http_body_util::BodyExt;use once_cell::sync::Lazy;use std::sync::Mutex;@@ -302,13 +303,23 @@ async fn cursor_client_sends_connect_proto_headers_and_run_request_frame() {let app = Router::new().route("/agent.v1.AgentService/Run",post(- move |headers: axum::http::HeaderMap, body: axum::body::Bytes| {+ move |headers: axum::http::HeaderMap, mut body: axum::body::Body| {let response_body = response_body.clone();let observed_handler = Arc::clone(&observed_handler);async move {+ let mut bytes = Vec::new();+ while let Some(Ok(frame)) = body.frame().await {+ if let Ok(data) = frame.into_data() {+ bytes.extend_from_slice(&data);+ }+ let mut decoder = ConnectFrameDecoder::new();+ if decoder.push(&bytes).is_ok_and(|frames| frames.len() >= 2) {+ break;+ }+ }*observed_handler.lock().unwrap() = Some(ObservedRequest {headers,- body: body.to_vec(),+ body: bytes,});([(@@ -412,37 +423,28 @@ async fn cursor_client_sends_connect_proto_headers_and_run_request_frame() {let mut decoder = ConnectFrameDecoder::new();let frames = decoder.push(&observed.body).unwrap();- assert_eq!(frames.len(), 1);+ assert!(frames.len() >= 2);assert_eq!(frames[0].flags, 0);- let msg = AgentClientMessage::decode(&frames[0].payload[..]).unwrap();- let run = msg.run_request.expect("run request");- assert!(msg.client_heartbeat.is_none());- assert_eq!(run.conversation_id, "");- assert_eq!(run.conversation_group_id, "");- assert!(run.client_supports_inline_images);- assert!(!run.exclude_workspace_context);- assert_eq!(run.requested_model.unwrap().model_id, "gpt-5.5");- let user_message = run- .action- .unwrap()- .user_message_action- .unwrap()- .user_message- .unwrap();- assert_eq!(user_message.text, "wire prompt");- assert_eq!(user_message.message_id, request_id);- assert_eq!(user_message.mode, "AGENT_MODE_AGENT");- let image = user_message- .selected_context- .unwrap()- .selected_images- .into_iter()- .next()- .unwrap();- assert_eq!(image.data, "aGVsbG8=");- assert_eq!(image.uuid, "image-id");- assert_eq!(image.path, "claude-image-1.png");- assert_eq!(image.mime_type, "image/png");+ assert_eq!(frames[0].payload.first().copied(), Some(0x0a));+ assert!(+ frames[0]+ .payload+ .windows(b"wire prompt".len())+ .any(|window| window == b"wire prompt")+ );+ assert!(+ frames[0]+ .payload+ .windows(b"gpt-5.5".len())+ .any(|window| window == b"gpt-5.5")+ );+ assert!(+ frames[0]+ .payload+ .windows(b"hello".len())+ .any(|window| window == b"hello")+ );+ assert_eq!(frames[1].payload.first().copied(), Some(0x12));unsafe {std::env::remove_var("CCP_CURSOR_BASE_URL");@@ -729,7 +731,7 @@ async fn cursor_provider_streams_text_and_usage_from_mock_upstream() {let app = Router::new().route("/agent.v1.AgentService/Run",- post(move |_body: axum::body::Bytes| async move {+ post(move |_body: axum::body::Body| async move {([(axum::http::header::CONTENT_TYPE,@@ -835,7 +837,7 @@ async fn cursor_provider_handle_messages_returns_anthropic_json() {let app = Router::new().route("/agent.v1.AgentService/Run",- post(move |_body: axum::body::Bytes| async move {+ post(move |_body: axum::body::Body| async move {([(axum::http::header::CONTENT_TYPE,@@ -958,16 +960,26 @@ async fn cursor_proxy_http_path_reaches_mock_cursor_upstream() {let upstream_app = Router::new().route("/agent.v1.AgentService/Run",post(- move |headers: axum::http::HeaderMap, body: axum::body::Bytes| {+ move |headers: axum::http::HeaderMap, mut body: axum::body::Body| {let response_body = response_body.clone();let observed_handler = Arc::clone(&observed_handler);async move {+ let mut bytes = Vec::new();+ while let Some(Ok(frame)) = body.frame().await {+ if let Ok(data) = frame.into_data() {+ bytes.extend_from_slice(&data);+ }+ let mut decoder = ConnectFrameDecoder::new();+ if decoder.push(&bytes).is_ok_and(|frames| frames.len() >= 2) {+ break;+ }+ }*observed_handler.lock().unwrap() = Some(ObservedRequest {authorization: headers.get(axum::http::header::AUTHORIZATION)- .and_then(|v| v.to_str().ok())+ .and_then(|value| value.to_str().ok()).map(str::to_string),- body: body.to_vec(),+ body: bytes,});([(@@ -1038,18 +1050,13 @@ async fn cursor_proxy_http_path_reaches_mock_cursor_upstream() {let mut decoder = ConnectFrameDecoder::new();let frames = decoder.push(&observed.body).unwrap();- assert_eq!(frames.len(), 1);- let msg = AgentClientMessage::decode(&frames[0].payload[..]).unwrap();- let user_message = msg- .run_request- .unwrap()- .action- .unwrap()- .user_message_action- .unwrap()- .user_message- .unwrap();- assert!(user_message.text.contains("hello over proxy"));+ assert!(frames.len() >= 2);+ assert!(+ frames[0]+ .payload+ .windows(b"hello over proxy".len())+ .any(|window| window == b"hello over proxy")+ );let _ = shutdown_tx.send(());unsafe {