Skip to content

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

Rust
51.0 KB
Raw Blame
//! 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 http_body_util::BodyExt;
use once_cell::sync::Lazy;
use std::sync::{Arc, Mutex};

static ENV_LOCK: Lazy<tokio::sync::Mutex<()>> = Lazy::new(|| tokio::sync::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,
        conversation_checkpoint_update: None,
        kv_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,
        }),
        exec_client_message: None,
        kv_client_message: None,
        exec_client_control_message: None,
        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.blocking_lock();
    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"));
}

#[tokio::test(flavor = "current_thread")]
async fn cursor_client_sends_connect_proto_headers_and_run_request_frame() {
    use axum::{Router, routing::post};
    use claude_code_proxy::providers::cursor::client::CursorHttpClient;
    use claude_code_proxy::providers::cursor::connect::{
        ConnectFrameDecoder, encode_connect_frame,
    };
    use claude_code_proxy::providers::cursor::proto::*;
    use claude_code_proxy::providers::cursor::request::CursorSelectedImage;
    use prost::Message;
    use std::sync::{Arc, Mutex};

    #[derive(Debug, Clone)]
    struct ObservedRequest {
        headers: axum::http::HeaderMap,
        body: Vec<u8>,
    }

    let _guard = ENV_LOCK.lock().await;
    let observed: Arc<Mutex<Option<ObservedRequest>>> = Arc::new(Mutex::new(None));
    let observed_handler = Arc::clone(&observed);

    let response_body = {
        let msg = AgentServerMessage {
            interaction_update: Some(InteractionUpdate {
                thinking_delta: None,
                text_delta: Some(TextDelta { text: "ok".into() }),
                turn_ended: Some(TurnEnded {
                    input_tokens: 1,
                    output_tokens: 1,
                    cache_read_tokens: 0,
                    cache_write_tokens: 0,
                }),
            }),
            exec_server_message: None,

            conversation_checkpoint_update: None,
            kv_server_message: None,
        };
        let mut payload = Vec::new();
        msg.encode(&mut payload).unwrap();
        let mut body = encode_connect_frame(&payload, 0).to_vec();
        body.extend_from_slice(&encode_connect_frame(b"", 2));
        body
    };

    let app = Router::new().route(
        "/agent.v1.AgentService/Run",
        post(
            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: bytes,
                    });
                    (
                        [(
                            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_CLIENT_VERSION", "test-client-version");
    }

    let _handle = tokio::spawn(async move {
        axum::serve(listener, app).await.unwrap();
    });

    tokio::time::sleep(std::time::Duration::from_millis(50)).await;

    let client = CursorHttpClient::new();
    let upstream = client
        .run_agent(
            "wire-token",
            "wire prompt",
            "cursor:gpt-5.5",
            &[CursorSelectedImage {
                data: "aGVsbG8=".into(),
                uuid: "image-id".into(),
                path: "claude-image-1.png".into(),
                mime_type: "image/png".into(),
            }],
        )
        .await
        .expect("mock upstream request should succeed");
    assert!(upstream.is_success());

    let observed = observed.lock().unwrap().clone().expect("request captured");
    assert_eq!(
        observed
            .headers
            .get(axum::http::header::AUTHORIZATION)
            .and_then(|v| v.to_str().ok()),
        Some("Bearer wire-token")
    );
    assert_eq!(
        observed
            .headers
            .get(axum::http::header::CONTENT_TYPE)
            .and_then(|v| v.to_str().ok()),
        Some("application/connect+proto")
    );
    assert_eq!(
        observed
            .headers
            .get("connect-protocol-version")
            .and_then(|v| v.to_str().ok()),
        Some("1")
    );
    assert_eq!(
        observed
            .headers
            .get("x-cursor-client-type")
            .and_then(|v| v.to_str().ok()),
        Some("cli")
    );
    assert_eq!(
        observed
            .headers
            .get("x-cursor-client-version")
            .and_then(|v| v.to_str().ok()),
        Some("test-client-version")
    );
    assert_eq!(
        observed
            .headers
            .get("x-cursor-streaming")
            .and_then(|v| v.to_str().ok()),
        Some("true")
    );
    let request_id = observed
        .headers
        .get("x-request-id")
        .and_then(|v| v.to_str().ok())
        .expect("x-request-id");
    assert_eq!(
        observed
            .headers
            .get("x-original-request-id")
            .and_then(|v| v.to_str().ok()),
        Some(request_id)
    );

    let mut decoder = ConnectFrameDecoder::new();
    let frames = decoder.push(&observed.body).unwrap();
    assert!(frames.len() >= 2);
    assert_eq!(frames[0].flags, 0);
    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");
        std::env::remove_var("CCP_CURSOR_CLIENT_VERSION");
    }
}

// ---------------------------------------------------------------------------
// 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,
        conversation_checkpoint_update: None,
        kv_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,
        conversation_checkpoint_update: None,
        kv_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,
        conversation_checkpoint_update: None,
        kv_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,
        conversation_checkpoint_update: None,
        kv_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,
        conversation_checkpoint_update: None,
        kv_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().await;

    // 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,
        conversation_checkpoint_update: None,
        kv_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,
        conversation_checkpoint_update: None,
        kv_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::Body| 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().await;

    // 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,
        conversation_checkpoint_update: None,
        kv_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::Body| 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(),
        traffic: None,
        monitor: None,
    };

    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");
    }
}

#[tokio::test(flavor = "current_thread")]
async fn cursor_proxy_http_path_reaches_mock_cursor_upstream() {
    use axum::{Router, routing::post};
    use claude_code_proxy::providers::cursor::connect::{
        ConnectFrameDecoder, encode_connect_frame,
    };
    use claude_code_proxy::providers::cursor::proto::*;
    use prost::Message;
    use std::sync::{Arc, Mutex};

    #[derive(Debug, Clone)]
    struct ObservedRequest {
        authorization: Option<String>,
        body: Vec<u8>,
    }

    let _guard = ENV_LOCK.lock().await;
    let observed: Arc<Mutex<Option<ObservedRequest>>> = Arc::new(Mutex::new(None));
    let observed_handler = Arc::clone(&observed);

    let response_body = {
        let text_msg = AgentServerMessage {
            interaction_update: Some(InteractionUpdate {
                thinking_delta: None,
                text_delta: Some(TextDelta {
                    text: "proxy path works".into(),
                }),
                turn_ended: None,
            }),
            exec_server_message: None,

            conversation_checkpoint_update: None,
            kv_server_message: None,
        };
        let mut text_payload = Vec::new();
        text_msg.encode(&mut text_payload).unwrap();

        let usage_msg = AgentServerMessage {
            interaction_update: Some(InteractionUpdate {
                thinking_delta: None,
                text_delta: None,
                turn_ended: Some(TurnEnded {
                    input_tokens: 12,
                    output_tokens: 3,
                    cache_read_tokens: 0,
                    cache_write_tokens: 0,
                }),
            }),
            exec_server_message: None,

            conversation_checkpoint_update: None,
            kv_server_message: None,
        };
        let mut usage_payload = Vec::new();
        usage_msg.encode(&mut usage_payload).unwrap();

        let mut body = encode_connect_frame(&text_payload, 0).to_vec();
        body.extend_from_slice(&encode_connect_frame(&usage_payload, 0));
        body.extend_from_slice(&encode_connect_frame(b"", 2));
        body
    };

    let upstream_app = Router::new().route(
        "/agent.v1.AgentService/Run",
        post(
            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(|value| value.to_str().ok())
                            .map(str::to_string),
                        body: bytes,
                    });
                    (
                        [(
                            axum::http::header::CONTENT_TYPE,
                            "application/connect+proto",
                        )],
                        response_body,
                    )
                }
            },
        ),
    );

    let upstream_listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
    let upstream_addr = upstream_listener.local_addr().unwrap();
    let upstream_url = format!("http://{}", upstream_addr);
    let _upstream_handle = tokio::spawn(async move {
        axum::serve(upstream_listener, upstream_app).await.unwrap();
    });

    let proxy_listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
    let proxy_addr = proxy_listener.local_addr().unwrap();
    let (shutdown_tx, shutdown_rx) = tokio::sync::oneshot::channel();
    let _proxy_handle = tokio::spawn(async move {
        claude_code_proxy::server::serve_listener(proxy_listener, None, async move {
            let _ = shutdown_rx.await;
        })
        .await
        .unwrap();
    });

    unsafe {
        std::env::set_var("CCP_CURSOR_BASE_URL", &upstream_url);
        std::env::set_var("CCP_CURSOR_AUTH_TOKEN", "proxy-token");
        std::env::set_var("CCP_CURSOR_CLIENT_VERSION", "proxy-test-version");
    }

    tokio::time::sleep(std::time::Duration::from_millis(50)).await;

    let client = reqwest::Client::new();
    let resp = client
        .post(format!("http://{proxy_addr}/v1/messages"))
        .header("authorization", "Bearer ignored")
        .json(&serde_json::json!({
            "model": "cursor:gpt-5.5",
            "max_tokens": 64,
            "messages": [{"role": "user", "content": "hello over proxy"}]
        }))
        .send()
        .await
        .unwrap();

    assert_eq!(resp.status(), reqwest::StatusCode::OK);
    let json: serde_json::Value = resp.json().await.unwrap();
    assert_eq!(json["content"][0]["text"], "proxy path works");
    assert_eq!(json["usage"]["input_tokens"], 12);
    assert_eq!(json["usage"]["output_tokens"], 3);

    let observed = observed
        .lock()
        .unwrap()
        .clone()
        .expect("upstream request captured");
    assert_eq!(
        observed.authorization.as_deref(),
        Some("Bearer proxy-token")
    );

    let mut decoder = ConnectFrameDecoder::new();
    let frames = decoder.push(&observed.body).unwrap();
    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 {
        std::env::remove_var("CCP_CURSOR_BASE_URL");
        std::env::remove_var("CCP_CURSOR_AUTH_TOKEN");
        std::env::remove_var("CCP_CURSOR_CLIENT_VERSION");
    }
}

// ---------------------------------------------------------------------------
// Live run: one stream across a tool round trip
// ---------------------------------------------------------------------------

/// The regression this bridge exists for: after Claude Code runs the tool, the
/// result has to travel back on the run that asked for it. A second `Run` makes
/// the agent re-plan from scratch and re-issue the same call.
#[tokio::test]
async fn live_run_answers_the_tool_result_on_the_same_stream() {
    use axum::Router;
    use axum::body::Body;
    use axum::routing::post;
    use claude_code_proxy::providers::cursor::connect::{
        ConnectFrameDecoder, encode_connect_frame,
    };
    use claude_code_proxy::providers::cursor::proto::*;
    use futures_util::StreamExt;
    use prost::Message;
    use std::sync::atomic::{AtomicUsize, Ordering};

    let _guard = ENV_LOCK.lock().await;
    let runs = Arc::new(AtomicUsize::new(0));
    let replies: Arc<Mutex<Vec<ExecClientMessage>>> = Arc::new(Mutex::new(Vec::new()));

    let app = {
        let runs = Arc::clone(&runs);
        let replies = Arc::clone(&replies);
        Router::new().route(
            "/agent.v1.AgentService/Run",
            post(move |body: Body| async move {
                runs.fetch_add(1, Ordering::SeqCst);
                let (tx, rx) = tokio::sync::mpsc::unbounded_channel();
                let replies = Arc::clone(&replies);

                tokio::spawn(async move {
                    let mut decoder = ConnectFrameDecoder::new();
                    let mut stream = body.into_data_stream();
                    let mut asked = false;
                    let mut answered = false;

                    while let Some(Ok(chunk)) = stream.next().await {
                        let frames = match decoder.push(&chunk) {
                            Ok(frames) => frames,
                            Err(_) => break,
                        };
                        if !asked && !frames.is_empty() {
                            // The run request has landed: ask for a tool.
                            asked = true;
                            let _ = tx.send(Ok(exec_frame()));
                        }
                        for frame in frames {
                            let message = match AgentClientMessage::decode(frame.payload.clone()) {
                                Ok(message) => message,
                                Err(_) => continue,
                            };
                            let Some(exec) = message.exec_client_message else {
                                continue;
                            };
                            replies.lock().unwrap().push(exec);
                            if !answered {
                                answered = true;
                                // The agent carries on with the result it got.
                                let _ = tx.send(Ok(text_frame("the tool returned grok-ok")));
                                let _ = tx.send(Ok(usage_frame(21, 7)));
                                let _ = tx.send(Ok(encode_connect_frame(b"", 2)));
                            }
                        }
                    }
                });

                let body =
                    Body::from_stream(futures_util::stream::unfold(rx, |mut rx| async move {
                        rx.recv().await.map(|item| {
                            (
                                item.map_err(|error: std::io::Error| {
                                    std::io::Error::other(error.to_string())
                                }),
                                rx,
                            )
                        })
                    }));
                (
                    [(
                        axum::http::header::CONTENT_TYPE,
                        "application/connect+proto",
                    )],
                    body,
                )
            }),
        )
    };

    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
    let addr = listener.local_addr().unwrap();
    let _handle = tokio::spawn(async move {
        axum::serve(listener, app).await.unwrap();
    });

    unsafe {
        std::env::set_var("CCP_CURSOR_BASE_URL", format!("http://{addr}"));
        std::env::set_var("CCP_CURSOR_AUTH_TOKEN", "proxy-token");
    }

    let provider = claude_code_proxy::providers::cursor::CursorProvider::new();
    let tools = serde_json::json!([
        {"name": "Bash", "description": "run", "input_schema": {"type": "object"}},
        {"name": "Read", "description": "read", "input_schema": {"type": "object"}},
        {"name": "Write", "description": "write", "input_schema": {"type": "object"}}
    ]);

    // Turn 1: the agent asks for a read.
    let first = serde_json::json!({
        "model": "cursor:gpt-5.5",
        "stream": true,
        "tools": tools,
        "messages": [{"role": "user", "content": "read /etc/hostname"}]
    });
    let first_sse = collect_sse(&provider, first, "probe-loop-1").await;
    let first_events = parse_sse_events(&first_sse);
    let tool_use_id = first_events
        .iter()
        .find_map(|(name, data)| {
            (name == "content_block_start" && data["content_block"]["type"] == "tool_use").then(
                || {
                    data["content_block"]["id"]
                        .as_str()
                        .unwrap_or("")
                        .to_string()
                },
            )
        })
        .expect("turn 1 asks for a tool");
    assert_eq!(
        first_events
            .iter()
            .find(|(name, _)| name == "message_delta")
            .map(|(_, data)| data["delta"]["stop_reason"].clone()),
        Some(serde_json::json!("tool_use"))
    );

    // Turn 2: Claude Code answers with the tool result.
    let second = serde_json::json!({
        "model": "cursor:gpt-5.5",
        "stream": true,
        "tools": tools,
        "messages": [
            {"role": "user", "content": "read /etc/hostname"},
            {"role": "assistant", "content": [
                {"type": "tool_use", "id": tool_use_id, "name": "Read",
                 "input": {"file_path": "/etc/hostname"}}
            ]},
            {"role": "user", "content": [
                {"type": "tool_result", "tool_use_id": tool_use_id, "content": "grok-ok"}
            ]}
        ]
    });
    let second_sse = collect_sse(&provider, second, "probe-loop-1").await;
    let second_events = parse_sse_events(&second_sse);

    let text: String = second_events
        .iter()
        .filter(|(name, _)| name == "content_block_delta")
        .filter_map(|(_, data)| data["delta"]["text"].as_str())
        .collect();
    assert!(
        text.contains("the tool returned grok-ok"),
        "turn 2 must carry the final answer, got {second_sse}"
    );
    assert!(
        !second_events
            .iter()
            .any(|(name, data)| name == "content_block_start"
                && data["content_block"]["type"] == "tool_use"),
        "turn 2 re-issued the tool call instead of using the result: {second_sse}"
    );

    // The whole round trip happened on ONE run, and the reply carried the exec
    // ids the agent gave us.
    assert_eq!(runs.load(Ordering::SeqCst), 1, "a second Run was started");
    let replies = replies.lock().unwrap().clone();
    assert_eq!(replies.len(), 1, "one exec reply");
    assert_eq!(replies[0].id, 1);
    assert_eq!(replies[0].exec_id, "exec-1");
    assert!(matches!(
        replies[0].message,
        Some(exec_client_message::Message::ReadResult(_))
    ));

    unsafe {
        std::env::remove_var("CCP_CURSOR_BASE_URL");
        std::env::remove_var("CCP_CURSOR_AUTH_TOKEN");
    }
}

/// A text-only turn still ends on the upstream's own end frame.
#[tokio::test]
async fn live_run_still_answers_plain_turns() {
    use axum::Router;
    use axum::routing::post;
    use claude_code_proxy::providers::cursor::connect::encode_connect_frame;
    use std::sync::atomic::{AtomicUsize, Ordering};

    let _guard = ENV_LOCK.lock().await;
    let runs = Arc::new(AtomicUsize::new(0));

    let app = {
        let runs = Arc::clone(&runs);
        Router::new().route(
            "/agent.v1.AgentService/Run",
            post(move |_body: axum::body::Body| async move {
                runs.fetch_add(1, Ordering::SeqCst);
                let mut body = text_frame("plain answer").to_vec();
                body.extend_from_slice(&usage_frame(9, 2));
                body.extend_from_slice(&encode_connect_frame(b"", 2));
                (
                    [(
                        axum::http::header::CONTENT_TYPE,
                        "application/connect+proto",
                    )],
                    body,
                )
            }),
        )
    };

    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
    let addr = listener.local_addr().unwrap();
    let _handle = tokio::spawn(async move {
        axum::serve(listener, app).await.unwrap();
    });

    unsafe {
        std::env::set_var("CCP_CURSOR_BASE_URL", format!("http://{addr}"));
        std::env::set_var("CCP_CURSOR_AUTH_TOKEN", "proxy-token");
    }

    let provider = claude_code_proxy::providers::cursor::CursorProvider::new();
    let sse = collect_sse(
        &provider,
        serde_json::json!({
            "model": "cursor:gpt-5.5",
            "stream": true,
            "tools": [{"name": "Read", "description": "read", "input_schema": {}}],
            "messages": [{"role": "user", "content": "hi"}]
        }),
        "probe-plain-1",
    )
    .await;

    let events = parse_sse_events(&sse);
    let text: String = events
        .iter()
        .filter(|(name, _)| name == "content_block_delta")
        .filter_map(|(_, data)| data["delta"]["text"].as_str())
        .collect();
    assert_eq!(text, "plain answer");
    assert!(events.iter().any(|(name, _)| name == "message_stop"));
    assert_eq!(runs.load(Ordering::SeqCst), 1);

    unsafe {
        std::env::remove_var("CCP_CURSOR_BASE_URL");
        std::env::remove_var("CCP_CURSOR_AUTH_TOKEN");
    }
}

/// Call the provider the way the proxy does and collect the whole SSE body.
async fn collect_sse(
    provider: &claude_code_proxy::providers::cursor::CursorProvider,
    body: serde_json::Value,
    session_id: &str,
) -> String {
    use claude_code_proxy::provider::{Provider, RequestContext};

    let request: claude_code_proxy::MessagesRequest = serde_json::from_value(body).unwrap();
    let response = provider
        .handle_messages(
            request,
            RequestContext {
                req_id: format!("test-{session_id}"),
                session_id: Some(session_id.to_string()),
                session_seq: None,
                provider: "cursor".to_string(),
                traffic: None,
                monitor: None,
            },
        )
        .await;
    let bytes = response
        .into_body()
        .collect()
        .await
        .expect("collect sse")
        .to_bytes();
    String::from_utf8_lossy(&bytes).to_string()
}

/// The frame the agent asks a tool in: AgentServerMessage tag 2 ->
/// ExecServerMessage id 1, read_args tag 7, exec_id tag 15.
fn exec_frame() -> bytes::Bytes {
    use claude_code_proxy::providers::cursor::connect::encode_connect_frame;
    use claude_code_proxy::providers::cursor::proto::*;
    use prost::Message;

    let message = AgentServerMessage {
        interaction_update: None,
        exec_server_message: Some(ExecServerMessage {
            id: Some(1),
            exec_id: Some("exec-1".to_string()),
            read_args: Some(ReadArgs {
                path: "/etc/hostname".to_string(),
                tool_call_id: Some("tool_abc".to_string()),
                ..Default::default()
            }),
            ..Default::default()
        }),

        conversation_checkpoint_update: None,
        kv_server_message: None,
    };
    encode_connect_frame(message.encode_to_vec(), 0)
}

fn text_frame(text: &str) -> bytes::Bytes {
    use claude_code_proxy::providers::cursor::connect::encode_connect_frame;
    use claude_code_proxy::providers::cursor::proto::*;
    use prost::Message;

    let message = AgentServerMessage {
        interaction_update: Some(InteractionUpdate {
            text_delta: Some(TextDelta {
                text: text.to_string(),
            }),
            ..Default::default()
        }),
        exec_server_message: None,
        conversation_checkpoint_update: None,
        kv_server_message: None,
    };
    encode_connect_frame(message.encode_to_vec(), 0)
}

fn usage_frame(input: u64, output: u64) -> bytes::Bytes {
    use claude_code_proxy::providers::cursor::connect::encode_connect_frame;
    use claude_code_proxy::providers::cursor::proto::*;
    use prost::Message;

    let message = AgentServerMessage {
        interaction_update: Some(InteractionUpdate {
            turn_ended: Some(TurnEnded {
                input_tokens: input,
                output_tokens: output,
                cache_read_tokens: 0,
                cache_write_tokens: 0,
            }),
            ..Default::default()
        }),
        exec_server_message: None,
        conversation_checkpoint_update: None,
        kv_server_message: None,
    };
    encode_connect_frame(message.encode_to_vec(), 0)
}

// ---------------------------------------------------------------------------
// No TypeScript sidecar
// ---------------------------------------------------------------------------

#[test]
fn cursor_provider_has_no_typescript_sidecar() {
    let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("src/providers/cursor");
    let mut stack = vec![root.clone()];
    while let Some(dir) = stack.pop() {
        match std::fs::read_dir(&dir) {
            Ok(entries) => {
                for entry in entries {
                    let path = entry.unwrap().path();
                    if path.is_dir() {
                        stack.push(path);
                        continue;
                    }
                    let ext = path.extension().and_then(|e| e.to_str());
                    assert_ne!(ext, Some("ts"), "TypeScript file found at {:?}", path);
                }
            }
            Err(_) => {
                // Directory may not exist (e.g., if cursor provider was removed)
                return;
            }
        }
    }
}

// ---------------------------------------------------------------------------
// 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 let Some(event) = line.strip_prefix("event: ") {
            current_event = event.to_string();
        } else if let Some(data_str) = line.strip_prefix("data: ")
            && let Ok(data) = serde_json::from_str::<serde_json::Value>(data_str)
        {
            events.push((current_event.clone(), data));
        }
    }

    events
}