Skip to content

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.rs
index 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.rs
index 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 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(),
+ 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, &parameter));
+ 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.rs
index 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.rs
index 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>, C
continue;
}
+ 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 info
if let Some(ref exec) = msg.exec_server_message
diff --git a/src/providers/cursor/test_frames.rs b/src/providers/cursor/test_frames.rs
index 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.rs
index 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 {