Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

50.7 KB
Raw Blame
//! Tests for the ACP adapter, driven over real transports.
//!
//! Most tests speak to the agent the way a client would: frames in, frames
//! out, over an in-memory [`Channel`] pair. That covers the whole path a
//! production frame takes — the SDK's parse, our handler, the SDK's response
//! — rather than a dispatch function called directly. One test drives the
//! byte-stream transport instead, because that is what the binary and the
//! Macro harness actually serve over, and it is where the frame-ordering
//! guarantee (a turn's updates precede its own response) is observable.

use super::*;
use crate::domain::event::CursorEvent;
use crate::domain::model::{CursorModel, CursorRunId, ModelParam, ModelVariant, RunStatus};
use crate::testing::{CursorCall, FakeCursor, FixedChooser};
use agent_client_protocol::schema::v1::InitializeResponse;
use agent_client_protocol::{Channel, RawJsonRpcMessage, TransportFrame};
use futures::StreamExt as _;
use futures::channel::mpsc;
use tokio::io::AsyncBufReadExt as _;
use tokio::io::AsyncWriteExt as _;

type Service = CursorSessionService<
    FakeCursor,
    AcpNotifier,
    FixedChooser,
    crate::domain::ports::NoArtifactStore,
>;

#[cfg(feature = "postgres")]
#[test]
fn admission_error_has_sanitized_retryable_protocol_details() {
    use agent_session::domain::error::AiAdmissionError;
    let error = prompt_error(&SessionError::Admission(AiAdmissionError::Unavailable));
    let value = serde_json::to_value(error).unwrap();
    assert_eq!(value["message"], AiAdmissionError::Unavailable.to_string());
    assert_eq!(
        value["data"],
        serde_json::json!({"code": "ai_billing_unavailable", "retryable": true})
    );
}

/// The client's end of a served connection.
struct TestClient {
    to_agent: mpsc::UnboundedSender<TransportFrame>,
    from_agent: mpsc::UnboundedReceiver<TransportFrame>,
}

impl TestClient {
    /// Send one frame, built by parsing the JSON a client would actually
    /// write, so the test exercises the same deserialize the wire does.
    fn send(&self, frame: serde_json::Value) {
        let message: RawJsonRpcMessage =
            serde_json::from_value(frame).expect("a well-formed frame");
        self.to_agent
            .unbounded_send(TransportFrame::Single(message))
            .expect("the connection is up");
    }

    /// The next frame the agent writes, as the JSON it would go out as.
    async fn next_frame(&mut self) -> serde_json::Value {
        let frame = tokio::time::timeout(std::time::Duration::from_secs(5), self.from_agent.next())
            .await
            .expect("a frame arrives before the test times out")
            .expect("the agent did not hang up");
        match frame {
            TransportFrame::Single(message) => {
                serde_json::to_value(&message).expect("frames serialize")
            }
            other => panic!("expected a single frame, got {other:?}"),
        }
    }

    /// One request/response round trip.
    async fn call(
        &mut self,
        id: i64,
        method: &str,
        params: serde_json::Value,
    ) -> serde_json::Value {
        self.send(serde_json::json!({
            "jsonrpc": "2.0",
            "id": id,
            "method": method,
            "params": params,
        }));
        loop {
            let frame = self.next_frame().await;
            if frame.get("id") == Some(&serde_json::json!(id)) {
                return frame;
            }
            assert!(
                matches!(
                    frame["method"].as_str(),
                    Some("session/update" | "_session/turn_complete")
                ),
                "expected the response or a session update, got {frame}"
            );
        }
    }

    /// The `available_commands_update` that follows `session/new` / `session/load`.
    async fn expect_available_commands(&mut self, session: &str) -> Vec<serde_json::Value> {
        let frame = self.next_frame().await;
        assert_eq!(frame["method"], "session/update", "{frame}");
        assert_eq!(frame["params"]["sessionId"], session);
        assert_eq!(
            frame["params"]["update"]["sessionUpdate"], "available_commands_update",
            "{frame}"
        );
        frame["params"]["update"]["availableCommands"]
            .as_array()
            .unwrap_or_else(|| panic!("availableCommands is an array in {frame}"))
            .clone()
    }
}

/// A served connection over a [`Channel`] pair, plus the pieces the tests
/// assert against.
fn harness() -> (Arc<Service>, FakeCursor, TestClient) {
    let cursor = FakeCursor::new();
    let (service, client) = serve_over_channel(cursor.clone(), |_| {});
    (service, cursor, client)
}

/// [`harness`], with a hook to shape the service before it starts serving —
/// what a real host does with [`CursorSessionService::restore_session`].
fn serve_over_channel(
    cursor: FakeCursor,
    configure: impl FnOnce(&Service),
) -> (Arc<Service>, TestClient) {
    serve_over_channel_with_default_model(cursor, None, configure)
}

/// [`serve_over_channel`], for a deployment that pins a model.
///
/// Separate because the default is fixed at construction: it is deployment
/// configuration, not something a client can set, and the service takes it by
/// value.
fn serve_over_channel_with_default_model(
    cursor: FakeCursor,
    default_model: Option<&str>,
    configure: impl FnOnce(&Service),
) -> (Arc<Service>, TestClient) {
    serve_over_channel_with_models(cursor, default_model, None, configure)
}

/// [`serve_over_channel`], for a session whose host record names a model.
///
/// The other half of [`serve_over_channel_with_default_model`]: both are fixed
/// at construction, because the hosted deployment builds one service per
/// session and hands it both preferences there.
fn serve_over_channel_with_host_model(
    cursor: FakeCursor,
    host_model: Option<&str>,
    configure: impl FnOnce(&Service),
) -> (Arc<Service>, TestClient) {
    serve_over_channel_with_models(cursor, None, host_model, configure)
}

fn serve_over_channel_with_models(
    cursor: FakeCursor,
    default_model: Option<&str>,
    host_model: Option<&str>,
    configure: impl FnOnce(&Service),
) -> (Arc<Service>, TestClient) {
    let notifier = AcpNotifier::new();
    let service = Arc::new(
        CursorSessionService::new(
            cursor,
            notifier.clone(),
            FixedChooser(None, false),
            Arc::new(crate::outbound::memory_journal::MemoryJournal::default()),
            crate::domain::ports::NoArtifactStore,
        )
        .with_default_model(default_model.map(str::to_owned))
        .with_host_model(host_model.map(str::to_owned)),
    );
    configure(&service);
    let (agent_end, client_end) = Channel::duplex();
    tokio::spawn(serve_transport(Arc::clone(&service), notifier, agent_end));
    (
        service,
        TestClient {
            to_agent: client_end.tx,
            from_agent: client_end.rx,
        },
    )
}

/// A response frame's `result`, panicking if it carried an error instead.
fn expect_result(frame: &serde_json::Value) -> serde_json::Value {
    assert!(
        frame.get("error").is_none(),
        "expected a result, got error {frame}"
    );
    frame
        .get("result")
        .cloned()
        .unwrap_or_else(|| panic!("no result in {frame}"))
}

/// A response frame's JSON-RPC error code, panicking if it succeeded.
fn expect_error_code(frame: &serde_json::Value) -> i64 {
    frame
        .pointer("/error/code")
        .and_then(serde_json::Value::as_i64)
        .unwrap_or_else(|| panic!("no error code in {frame}"))
}

/// `initialize` must answer with a version the client can actually speak.
///
/// The response version was once hardcoded to `V1` regardless of the request,
/// so a client offering only v0 was told v1 and the two then disagreed about
/// the wire format with nothing to detect it.
#[tokio::test]
async fn initialize_negotiates_down_to_the_clients_version() {
    let (_service, _cursor, mut client) = harness();

    let frame = client
        .call(1, "initialize", serde_json::json!({ "protocolVersion": 0 }))
        .await;

    let response: InitializeResponse =
        serde_json::from_value(expect_result(&frame)).expect("an initialize response");
    assert_eq!(
        response.protocol_version,
        ProtocolVersion::V0,
        "a client that offered v0 must not be answered v1"
    );
}

/// A client offering a version newer than ours gets ours, not its own.
#[tokio::test]
async fn initialize_caps_a_newer_client_at_our_version() {
    let (_service, _cursor, mut client) = harness();

    let frame = client
        .call(
            1,
            "initialize",
            serde_json::json!({ "protocolVersion": 99 }),
        )
        .await;

    let response: InitializeResponse =
        serde_json::from_value(expect_result(&frame)).expect("an initialize response");
    assert_eq!(response.protocol_version, ProtocolVersion::V1);
}

/// `prompt_text` already turns a `ResourceLink` into an `@`-mention, so
/// advertising `embeddedContext: false` suppresses context the agent handles
/// perfectly well.
#[tokio::test]
async fn initialize_advertises_the_prompt_capabilities_we_actually_have() {
    let (_service, _cursor, mut client) = harness();

    let frame = client
        .call(1, "initialize", serde_json::json!({ "protocolVersion": 1 }))
        .await;

    let response: InitializeResponse =
        serde_json::from_value(expect_result(&frame)).expect("an initialize response");
    let capabilities = &response.agent_capabilities.prompt_capabilities;
    assert!(
        capabilities.embedded_context,
        "resource links are handled, so embedded context must be advertised"
    );
    assert!(
        capabilities.image,
        "pasted image links are fetched and sent as prompt images"
    );
    assert!(!capabilities.audio);
}

/// `session/close` must be served, or `CursorSessionService::close` is dead
/// code and the session map grows for the whole process lifetime.
#[tokio::test]
async fn session_close_forgets_the_session() {
    let (service, _cursor, mut client) = harness();

    let opened = client
        .call(
            1,
            "session/new",
            serde_json::json!({ "cwd": "/workspace", "mcpServers": [] }),
        )
        .await;
    let session = expect_result(&opened)["sessionId"]
        .as_str()
        .expect("a session id")
        .to_owned();

    let closed = client
        .call(
            2,
            "session/close",
            serde_json::json!({ "sessionId": session.clone() }),
        )
        .await;
    let _ = expect_result(&closed);

    // The service must no longer know it.
    let error = service
        .prompt(&SessionId::new(session), "hi")
        .await
        .expect_err("a closed session is gone");
    assert!(matches!(
        error,
        crate::domain::error::SessionError::UnknownSession(_)
    ));
}

/// Closing a session that was never opened is an error, not a panic.
#[tokio::test]
async fn closing_an_unknown_session_is_an_error() {
    let (_service, _cursor, mut client) = harness();

    let frame = client
        .call(
            1,
            "session/close",
            serde_json::json!({ "sessionId": "nope" }),
        )
        .await;

    assert_eq!(
        expect_error_code(&frame),
        -32602,
        "an unknown session is invalid params"
    );
}

/// A `session/new` that omits `mcpServers` is refused, not guessed at.
///
/// ACP marks the member required, so a conformant client always sends it —
/// as `[]` when it configures nothing. This agent used to inject the empty
/// list itself; now that the schema parses the request before the handler
/// runs, the schema's strictness is the behaviour, and it matches what the
/// field's absence actually means: a client this agent does not understand.
#[tokio::test]
async fn session_new_requires_the_mcp_servers_member() {
    let (_service, _cursor, mut client) = harness();

    let frame = client
        .call(1, "session/new", serde_json::json!({ "cwd": "/workspace" }))
        .await;

    assert_eq!(expect_error_code(&frame), -32602);
}

/// Methods this agent genuinely does not implement still answer properly.
#[tokio::test]
async fn unimplemented_methods_answer_method_not_found() {
    let (_service, _cursor, mut client) = harness();

    for (id, method) in [(1, "session/set_mode"), (2, "session/fork"), (3, "logout")] {
        let frame = client.call(id, method, serde_json::json!({})).await;
        assert_eq!(
            expect_error_code(&frame),
            -32601,
            "{method} should be method_not_found"
        );
    }
}

/// A `session/new` carrying MCP servers still opens a session — dropping the
/// request would be worse than ignoring a field we cannot honour — but the
/// servers are not silently accepted, they are warned about.
#[tokio::test]
async fn session_new_still_succeeds_when_mcp_servers_are_named() {
    let (_service, _cursor, mut client) = harness();

    let frame = client
        .call(
            1,
            "session/new",
            serde_json::json!({
                "cwd": "/workspace",
                "mcpServers": [{ "name": "whatever", "command": "x", "args": [] }],
            }),
        )
        .await;

    assert!(
        expect_result(&frame)["sessionId"].is_string(),
        "an unhonourable field must not fail the request"
    );
}

/// The frame reader half of an in-process client: one JSON frame per line.
async fn next_client_frame<Reader>(lines: &mut tokio::io::Lines<Reader>) -> serde_json::Value
where
    Reader: tokio::io::AsyncBufRead + Unpin,
{
    let line = tokio::time::timeout(std::time::Duration::from_secs(5), lines.next_line())
        .await
        .expect("a frame arrives before the test times out")
        .expect("the pipe is readable")
        .expect("the agent did not hang up");
    serde_json::from_str(&line).expect("a json frame")
}

/// Write one frame as the client would: JSON, one line, no more.
async fn send_client_frame<Writer>(writer: &mut Writer, frame: serde_json::Value)
where
    Writer: tokio::io::AsyncWrite + Unpin,
{
    writer
        .write_all(format!("{frame}\n").as_bytes())
        .await
        .expect("the pipe is writable");
}

/// The byte-stream transport carries a whole conversation, and in order.
///
/// This is the transport the binary and the Macro harness actually serve
/// over: newline-delimited JSON on a byte pipe. The frame order is the other
/// half of the point — the turn's `session/update` notification has to
/// precede the `session/prompt` response, which holds because notifications
/// and responses share the connection's one outgoing queue.
#[tokio::test]
async fn serve_runs_a_whole_conversation_over_an_in_process_pipe() {
    let (client_side, agent_side) = tokio::io::duplex(16 * 1024);
    let (agent_reader, agent_writer) = tokio::io::split(agent_side);
    let (client_reader, mut client_writer) = tokio::io::split(client_side);
    let mut client_frames = tokio::io::BufReader::new(client_reader).lines();

    let cursor = FakeCursor::new();
    let events = cursor.script_stream();
    let notifier = AcpNotifier::new();
    let service = Arc::new(CursorSessionService::new(
        cursor,
        notifier.clone(),
        FixedChooser(None, false),
        Arc::new(crate::outbound::memory_journal::MemoryJournal::default()),
        crate::domain::ports::NoArtifactStore,
    ));
    let serve_task = tokio::spawn(serve(service, notifier, agent_reader, agent_writer));

    send_client_frame(
        &mut client_writer,
        serde_json::json!({
            "jsonrpc": "2.0", "id": 1,
            "method": "initialize", "params": { "protocolVersion": 1 },
        }),
    )
    .await;
    let initialize = next_client_frame(&mut client_frames).await;
    assert_eq!(initialize["id"], 1);
    assert_eq!(initialize["result"]["protocolVersion"], 1);

    send_client_frame(
        &mut client_writer,
        serde_json::json!({
            "jsonrpc": "2.0", "id": 2,
            "method": "session/new",
            "params": { "cwd": "/workspace", "mcpServers": [] },
        }),
    )
    .await;
    let opened = next_client_frame(&mut client_frames).await;
    assert_eq!(opened["id"], 2);
    let session = opened["result"]["sessionId"]
        .as_str()
        .expect("a session id")
        .to_owned();
    let commands = next_client_frame(&mut client_frames).await;
    assert_eq!(commands["method"], "session/update");
    assert_eq!(
        commands["params"]["update"]["sessionUpdate"],
        "available_commands_update"
    );

    send_client_frame(
        &mut client_writer,
        serde_json::json!({
            "jsonrpc": "2.0", "id": 3,
            "method": "session/prompt",
            "params": {
                "sessionId": session,
                "prompt": [{ "type": "text", "text": "do it" }],
            },
        }),
    )
    .await;
    events
        .send(CursorEvent::Assistant {
            text: "hello".to_owned(),
        })
        .expect("stream open");
    events
        .send(CursorEvent::Result {
            run_id: CursorRunId::new("run-fake-1"),
            status: RunStatus::Finished,
            text: None,
            duration_ms: Some(1),
            git: None,
        })
        .expect("stream open");
    events.send(CursorEvent::Done).expect("stream open");
    drop(events);

    let update = next_client_frame(&mut client_frames).await;
    assert_eq!(update["method"], "session/update");
    assert_eq!(update["params"]["sessionId"], session.as_str());
    assert_eq!(
        update["params"]["update"]["content"]["text"], "hello",
        "the streamed assistant text must reach the client, in {update}"
    );

    let checkpoint = next_client_frame(&mut client_frames).await;
    assert_eq!(checkpoint["method"], "session/update");
    assert_eq!(
        checkpoint["params"]["_meta"]["macroCursorRunCheckpoint"],
        "run-fake-1"
    );

    let answered = next_client_frame(&mut client_frames).await;
    assert_eq!(answered["id"], 3, "the response follows its own updates");
    assert_eq!(answered["result"]["stopReason"], "end_turn");

    // Hanging up the client end is EOF for the connection, which drains any
    // queued frames and resolves. Both halves have to go: `tokio::io::split`
    // only closes the pipe once the last of them is dropped.
    drop(client_writer);
    drop(client_frames);
    serve_task
        .await
        .expect("the serve task joins")
        .expect("clean eof resolves ok");
}

/// Remote MCP servers named at `session/new` are forwarded to Cursor.
///
/// `POST /v1/agents` accepts `mcpServers[]` with `url`/`headers`, so an HTTP
/// or SSE server the client configures is genuinely reachable from the cloud
/// agent — there is nothing to decline.
#[tokio::test]
async fn remote_mcp_servers_are_forwarded_to_the_agent() {
    let (service, cursor, mut client) = harness();

    let opened = client
        .call(
            1,
            "session/new",
            serde_json::json!({
                "cwd": "/workspace",
                "mcpServers": [
                    {
                        "type": "http",
                        "name": "docs",
                        "url": "https://mcp.example.com",
                        "headers": [{ "name": "Authorization", "value": "Bearer t" }],
                    },
                    {
                        "type": "sse",
                        "name": "events",
                        "url": "https://mcp.example.com/sse",
                        "headers": [],
                    },
                ],
            }),
        )
        .await;
    let session = expect_result(&opened)["sessionId"]
        .as_str()
        .expect("a session id")
        .to_owned();

    let events = cursor.script_stream();
    events
        .send(CursorEvent::Result {
            run_id: CursorRunId::new("run-fake-1"),
            status: RunStatus::Finished,
            text: None,
            duration_ms: None,
            git: None,
        })
        .expect("stream open");
    events.send(CursorEvent::Done).expect("stream open");
    service
        .prompt(&SessionId::new(session), "go")
        .await
        .expect("prompt runs");

    let calls = cursor.calls();
    let [CursorCall::CreateAgent(_, _, _, servers, _, _)] = calls.as_slice() else {
        panic!("expected one create_agent, got {calls:?}");
    };
    assert_eq!(
        servers,
        &vec![
            McpServer {
                name: "docs".to_owned(),
                transport: McpTransport::Http,
                url: "https://mcp.example.com".to_owned(),
                headers: vec![McpHeader {
                    name: "Authorization".to_owned(),
                    value: "Bearer t".to_owned(),
                }],
            },
            McpServer {
                name: "events".to_owned(),
                transport: McpTransport::Sse,
                url: "https://mcp.example.com/sse".to_owned(),
                headers: Vec::new(),
            },
        ]
    );
}

/// A stdio MCP server is declined, not forwarded.
///
/// ACP defines `command` as an absolute path on the *client's* machine, and
/// its `env` carries literal values that are routinely credentials. Sending
/// either to Cursor's sandbox would spawn something else, somewhere else,
/// with the user's secrets — and look configured while doing it. The session
/// still opens; only the unhonourable server is dropped.
#[tokio::test]
async fn stdio_mcp_servers_are_declined_without_failing_the_session() {
    let (service, cursor, mut client) = harness();

    let opened = client
        .call(
            1,
            "session/new",
            serde_json::json!({
                "cwd": "/workspace",
                "mcpServers": [
                    {
                        "name": "local",
                        "command": "/usr/local/bin/my-mcp",
                        "args": ["--stdio"],
                        "env": [{ "name": "TOKEN", "value": "secret" }],
                    },
                    {
                        "type": "http",
                        "name": "remote",
                        "url": "https://mcp.example.com",
                        "headers": [],
                    },
                ],
            }),
        )
        .await;
    let session = expect_result(&opened)["sessionId"]
        .as_str()
        .expect("a session id")
        .to_owned();

    let events = cursor.script_stream();
    events
        .send(CursorEvent::Result {
            run_id: CursorRunId::new("run-fake-1"),
            status: RunStatus::Finished,
            text: None,
            duration_ms: None,
            git: None,
        })
        .expect("stream open");
    events.send(CursorEvent::Done).expect("stream open");
    service
        .prompt(&SessionId::new(session), "go")
        .await
        .expect("prompt runs");

    let calls = cursor.calls();
    let [CursorCall::CreateAgent(_, _, _, servers, _, _)] = calls.as_slice() else {
        panic!("expected one create_agent");
    };
    let names: Vec<&str> = servers.iter().map(|server| server.name.as_str()).collect();
    assert_eq!(
        names,
        vec!["remote"],
        "the stdio server must be dropped and the remote one kept"
    );
}

/// The capabilities must claim the remote transports, because they are really
/// forwarded — advertising false suppressed servers that work.
#[tokio::test]
async fn initialize_advertises_the_remote_mcp_transports() {
    let (_service, _cursor, mut client) = harness();

    let frame = client
        .call(1, "initialize", serde_json::json!({ "protocolVersion": 1 }))
        .await;

    let response: InitializeResponse =
        serde_json::from_value(expect_result(&frame)).expect("an initialize response");
    let mcp = &response.agent_capabilities.mcp_capabilities;
    assert!(mcp.http, "http MCP servers are forwarded");
    assert!(mcp.sse, "sse MCP servers are forwarded");
}

/// The whole handshake, pinned.
///
/// The tests above assert *why* individual capabilities are what they are —
/// that reasoning is the point of them, and it stays readable as the set
/// grows. This pins the entire response instead, so a capability appearing or
/// disappearing shows up as a diff no matter which one it is. Capabilities are
/// promises to the client about what it may send; one drifting unnoticed means
/// clients either suppress input the agent handles or send input it drops.
#[tokio::test]
async fn the_initialize_response_is_pinned_whole() {
    let (_service, _cursor, mut client) = harness();

    let frame = client
        .call(1, "initialize", serde_json::json!({ "protocolVersion": 1 }))
        .await;

    let mut response = expect_result(&frame);
    // The version moves with the crate; everything else is the contract.
    if let Some(info) = response
        .get_mut("agentInfo")
        .and_then(|info| info.as_object_mut())
    {
        info.insert("version".to_owned(), serde_json::json!("[crate version]"));
    }
    insta::assert_json_snapshot!(response);
}

/// `session/load` finds a restored session and refuses an unknown one. The
/// restored path is what a Macro harness restart walks: restore, load, then
/// prompt the existing agent.
#[tokio::test]
async fn session_load_answers_for_restored_sessions_only() {
    let (_service, mut client) = serve_over_channel(FakeCursor::new(), |service| {
        service.restore_session(
            SessionId::new("cursor-acp-3"),
            Some(crate::domain::model::CursorAgentId::new("bc-restored")),
            None,
        );
    });

    let loaded = client
        .call(
            1,
            "session/load",
            serde_json::json!({
                "sessionId": "cursor-acp-3", "cwd": "/workspace", "mcpServers": [],
            }),
        )
        .await;
    assert!(
        loaded.get("error").is_some(),
        "legacy session without native history must fail: {loaded}"
    );

    let unknown = client
        .call(
            2,
            "session/load",
            serde_json::json!({
                "sessionId": "cursor-acp-999", "cwd": "/workspace", "mcpServers": [],
            }),
        )
        .await;
    assert!(unknown.get("error").is_some(), "got {unknown}");
}

/// Two models, the second with a non-trivial default variant, as
/// `GET /v1/models` would report them.
fn offered_models() -> Vec<CursorModel> {
    vec![
        CursorModel {
            id: "composer-2.5".to_owned(),
            display_name: "Composer 2.5".to_owned(),
            variants: vec![ModelVariant {
                params: Vec::new(),
                is_default: true,
            }],
        },
        CursorModel {
            id: "gpt-5.5".to_owned(),
            display_name: "GPT-5.5".to_owned(),
            variants: vec![
                ModelVariant {
                    params: vec![
                        ModelParam {
                            id: "reasoning".to_owned(),
                            value: "low".to_owned(),
                        },
                        ModelParam {
                            id: "fast".to_owned(),
                            value: "true".to_owned(),
                        },
                    ],
                    is_default: false,
                },
                ModelVariant {
                    params: vec![
                        ModelParam {
                            id: "reasoning".to_owned(),
                            value: "medium".to_owned(),
                        },
                        ModelParam {
                            id: "fast".to_owned(),
                            value: "true".to_owned(),
                        },
                    ],
                    is_default: true,
                },
            ],
        },
    ]
}

/// `session/new` advertises the account's models as an ACP select, which is the
/// whole of how a client learns what it may pick.
#[tokio::test]
async fn session_new_advertises_the_models_as_a_config_option() {
    let cursor = FakeCursor::new();
    cursor.script_models(offered_models());
    let (_service, mut client) =
        serve_over_channel_with_default_model(cursor, Some("composer-2.5"), |_| {});

    let response = client
        .call(
            1,
            "session/new",
            serde_json::json!({"cwd": "/workspace", "mcpServers": []}),
        )
        .await;
    let result = expect_result(&response);
    let options = result["configOptions"]
        .as_array()
        .expect("config options are advertised");
    let [option] = options.as_slice() else {
        panic!("expected exactly the model option, got {options:?}");
    };
    assert_eq!(option["id"], "model");
    assert_eq!(option["currentValue"], "composer-2.5");
    let values: Vec<&str> = option["options"]
        .as_array()
        .expect("selectable options")
        .iter()
        .map(|entry| entry["value"].as_str().expect("a value id"))
        .collect();
    assert_eq!(values, vec!["composer-2.5", "gpt-5.5"]);
}

/// `session/new` advertises Cursor's cloud slash commands after the session
/// exists, which is how the agents-block composer learns to open `/`.
#[tokio::test]
async fn session_new_advertises_cursor_slash_commands() {
    let (_service, _cursor, mut client) = harness();

    let opened = client
        .call(
            1,
            "session/new",
            serde_json::json!({"cwd": "/workspace", "mcpServers": []}),
        )
        .await;
    let session = expect_result(&opened)["sessionId"]
        .as_str()
        .expect("a session id")
        .to_owned();
    let commands = client.expect_available_commands(&session).await;
    let names: Vec<String> = commands
        .iter()
        .map(|command| command["name"].as_str().expect("a command name").to_owned())
        .collect();
    let expected: Vec<String> = crate::domain::slash_commands::cursor_slash_commands()
        .into_iter()
        .map(|command| command.name)
        .collect();
    assert_eq!(
        names, expected,
        "session/new must advertise the curated catalog, in catalog order"
    );
}

/// `session/load` re-advertises the same catalog, so a resumed session's `/`
/// menu is not empty until the next `session/new`.
#[tokio::test]
async fn session_load_advertises_cursor_slash_commands() {
    let cursor = FakeCursor::new();
    crate::testing::script_legacy_history(&cursor);
    let (_service, mut client) = serve_over_channel(cursor, |service| {
        service.restore_session(
            SessionId::new("cursor-acp-3"),
            Some(crate::domain::model::CursorAgentId::new("bc-restored")),
            None,
        );
    });

    let loaded = client
        .call(
            1,
            "session/load",
            serde_json::json!({"sessionId": "cursor-acp-3", "cwd": "/workspace", "mcpServers": []}),
        )
        .await;
    expect_result(&loaded);
    let commands = client.expect_available_commands("cursor-acp-3").await;
    let names: Vec<&str> = commands
        .iter()
        .map(|command| command["name"].as_str().expect("a command name"))
        .collect();
    assert!(
        names.contains(&"goal"),
        "a resumed session must still advertise commands, got {names:?}"
    );
}

/// With two models of one family in the listing, the select goes out as ACP
/// groups headed by family — `Claude Opus` once, its versions under it — in
/// listing order, and the flat fixture above stays flat: singletons gain
/// nothing from a header each.
#[tokio::test]
async fn a_listing_with_families_is_advertised_as_headed_groups() {
    let cursor = FakeCursor::new();
    let mut models = offered_models();
    models.extend([
        CursorModel {
            id: "claude-opus-5".to_owned(),
            display_name: "Claude Opus 5".to_owned(),
            variants: Vec::new(),
        },
        CursorModel {
            id: "claude-opus-4.8".to_owned(),
            display_name: "Claude Opus 4.8".to_owned(),
            variants: Vec::new(),
        },
    ]);
    cursor.script_models(models);
    let (_service, mut client) =
        serve_over_channel_with_default_model(cursor, Some("claude-opus-5"), |_| {});

    let response = client
        .call(
            1,
            "session/new",
            serde_json::json!({"cwd": "/workspace", "mcpServers": []}),
        )
        .await;
    let option = &expect_result(&response)["configOptions"][0];
    assert_eq!(option["currentValue"], "claude-opus-5");
    let groups: Vec<(&str, &str, Vec<&str>)> = option["options"]
        .as_array()
        .expect("grouped options")
        .iter()
        .map(|group| {
            (
                group["group"].as_str().expect("a group id"),
                group["name"].as_str().expect("a group name"),
                group["options"]
                    .as_array()
                    .expect("a group's options")
                    .iter()
                    .map(|entry| entry["value"].as_str().expect("a value id"))
                    .collect(),
            )
        })
        .collect();
    assert_eq!(
        groups,
        vec![
            ("composer", "Composer", vec!["composer-2.5"]),
            ("gpt", "GPT", vec!["gpt-5.5"]),
            (
                "claude-opus",
                "Claude Opus",
                vec!["claude-opus-5", "claude-opus-4.8"]
            ),
        ]
    );
}

/// Setting the model mid-session is accepted and reflected back, and the next
/// run carries it — the point being that Cursor honours `model` on a follow-up
/// run, so a change does not have to wait for a new agent.
#[tokio::test]
async fn setting_the_model_and_effort_changes_what_the_next_run_asks_for() {
    let cursor = FakeCursor::new();
    cursor.script_models(offered_models());
    let (_service, mut client) =
        serve_over_channel_with_default_model(cursor.clone(), Some("composer-2.5"), |_| {});

    let session = expect_result(
        &client
            .call(
                1,
                "session/new",
                serde_json::json!({"cwd": "/workspace", "mcpServers": []}),
            )
            .await,
    )["sessionId"]
        .as_str()
        .expect("a session id")
        .to_owned();

    let response = client
        .call(
            2,
            "session/set_config_option",
            serde_json::json!({
                "sessionId": session,
                "configId": "model",
                "value": "gpt-5.5",
            }),
        )
        .await;
    let result = expect_result(&response);
    // Answered with the whole option set, so a client folds config from one
    // shape whichever response carried it.
    assert_eq!(result["configOptions"][0]["currentValue"], "gpt-5.5");
    assert_eq!(result["configOptions"][1]["id"], "reasoning_effort");
    assert_eq!(result["configOptions"][1]["currentValue"], "medium");

    let response = client
        .call(
            3,
            "session/set_config_option",
            serde_json::json!({
                "sessionId": session,
                "configId": "reasoning_effort",
                "value": "low",
            }),
        )
        .await;
    let result = expect_result(&response);
    assert_eq!(result["configOptions"][1]["currentValue"], "low");

    // And the run actually asks for it. This is the behaviour the whole feature
    // rests on: Cursor honours `model` on a follow-up run, so the choice does
    // not have to wait for a new agent — and it must carry the variant's params,
    // because Cursor rejects an id whose params are not a variant it knows.
    let events = cursor.script_stream();
    events
        .send(CursorEvent::Result {
            run_id: CursorRunId::new("run-fake-1"),
            status: RunStatus::Finished,
            text: None,
            duration_ms: Some(1),
            git: None,
        })
        .expect("stream open");
    events.send(CursorEvent::Done).expect("stream open");
    client
        .call(
            4,
            "session/prompt",
            serde_json::json!({
                "sessionId": session,
                "prompt": [{"type": "text", "text": "go"}],
            }),
        )
        .await;

    let asked = cursor
        .calls()
        .into_iter()
        .find_map(|call| match call {
            CursorCall::CreateAgent(_, _, _, _, model, _) => Some(model),
            _ => None,
        })
        .expect("the turn created an agent");
    let asked = asked.expect("the turn named a model");
    assert_eq!(asked.id, "gpt-5.5");
    assert_eq!(
        asked.params,
        vec![
            ModelParam {
                id: "reasoning".to_owned(),
                value: "low".to_owned(),
            },
            ModelParam {
                id: "fast".to_owned(),
                value: "true".to_owned(),
            }
        ],
        "the selected effort travels as Cursor's accepted model variant"
    );
}

/// An id this account was never offered is refused here, with the list, rather
/// than accepted and left to fail at the next prompt as a Cursor
/// `validation_error`.
#[tokio::test]
async fn setting_an_unoffered_model_is_refused() {
    let cursor = FakeCursor::new();
    cursor.script_models(offered_models());
    let (_service, mut client) =
        serve_over_channel_with_default_model(cursor, Some("composer-2.5"), |_| {});

    let session = expect_result(
        &client
            .call(
                1,
                "session/new",
                serde_json::json!({"cwd": "/workspace", "mcpServers": []}),
            )
            .await,
    )["sessionId"]
        .as_str()
        .expect("a session id")
        .to_owned();

    let response = client
        .call(
            2,
            "session/set_config_option",
            serde_json::json!({
                "sessionId": session,
                "configId": "model",
                "value": "gpt-9-imaginary",
            }),
        )
        .await;
    assert!(
        response.get("error").is_some(),
        "expected an error, got {response}"
    );
}

/// A refusal the person can act on answers the prompt with its notice in the
/// error's `data` - where the fold reads it - and a one-sentence message,
/// never the report with its source locations.
#[tokio::test]
async fn a_usage_limit_refusal_answers_the_prompt_with_a_notice() {
    let cursor = FakeCursor::new();
    cursor.script_usage_limit_rejection();
    let (_service, mut client) = serve_over_channel(cursor, |_| {});

    let session = expect_result(
        &client
            .call(
                1,
                "session/new",
                serde_json::json!({"cwd": "/workspace", "mcpServers": []}),
            )
            .await,
    )["sessionId"]
        .as_str()
        .expect("a session id")
        .to_owned();

    let response = client
        .call(
            2,
            "session/prompt",
            serde_json::json!({
                "sessionId": session,
                "prompt": [{ "type": "text", "text": "do it" }],
            }),
        )
        .await;

    let error = response.get("error").expect("a refused prompt is an error");
    assert_eq!(error["data"]["kind"], "provider_usage_limit");
    assert_eq!(error["data"]["title"], "Cursor usage limit reached");
    assert_eq!(
        error["data"]["link"]["url"],
        "https://www.cursor.com/dashboard?tab=settings"
    );
    let message = error["message"].as_str().expect("a message");
    assert!(
        !message.contains("usage_limit_exceeded") && !message.contains(".rs:"),
        "cursor's body and the report stay in the logs: {message}"
    );
}

/// A restored session's next run asks for the model it was using before the
/// restart, params re-resolved from the live model table.
///
/// The regression this pins: the wrapper's model selection was in-memory only,
/// so after a resume the UI kept showing the picked model while the runs went
/// to whatever Cursor resolved — a silent divergence.
#[tokio::test]
async fn a_restored_session_keeps_its_model() {
    let cursor = FakeCursor::new();
    cursor.script_models(offered_models());
    crate::testing::script_legacy_history(&cursor);
    let (service, mut client) =
        serve_over_channel_with_host_model(cursor.clone(), Some("gpt-5.5"), |service| {
            service.restore_session(
                SessionId::new("cursor-acp-3"),
                Some(crate::domain::model::CursorAgentId::new("bc-restored")),
                None,
            );
        });

    // The picker is repopulated at load, current value included — this is the
    // other half of the regression, where the options came back empty.
    let loaded = client
        .call(
            1,
            "session/load",
            serde_json::json!({"sessionId": "cursor-acp-3", "cwd": "/workspace", "mcpServers": []}),
        )
        .await;
    let result = expect_result(&loaded);
    assert_eq!(result["configOptions"][0]["currentValue"], "gpt-5.5");

    let events = cursor.script_stream();
    events
        .send(CursorEvent::Result {
            run_id: CursorRunId::new("run-fake-1"),
            status: RunStatus::Finished,
            text: None,
            duration_ms: None,
            git: None,
        })
        .expect("stream open");
    events.send(CursorEvent::Done).expect("stream open");
    service
        .prompt(&SessionId::new("cursor-acp-3"), "go")
        .await
        .expect("prompt runs");

    let asked = cursor
        .calls()
        .into_iter()
        .find_map(|call| match call {
            CursorCall::CreateRun(_, _, model, _) => Some(model),
            _ => None,
        })
        .expect("the restored agent got a follow-up run");
    let asked = asked.expect("the run named the restored model");
    assert_eq!(asked.id, "gpt-5.5");
    assert_eq!(
        asked.params,
        vec![
            ModelParam {
                id: "reasoning".to_owned(),
                value: "medium".to_owned(),
            },
            ModelParam {
                id: "fast".to_owned(),
                value: "true".to_owned(),
            }
        ],
        "params come from the live table's default variant, not from persistence"
    );
}

/// A restored id that is not a Cursor model resolves to "no opinion", not an
/// error. This is the common case, not a corner: the harness seeds its
/// session records with a deployment slug like `claude`, and every session
/// where nobody ever picked presents that slug at resume.
#[tokio::test]
async fn a_restored_deployment_slug_falls_back_to_cursors_default() {
    let cursor = FakeCursor::new();
    cursor.script_models(offered_models());
    crate::testing::script_legacy_history(&cursor);
    let (service, mut client) =
        serve_over_channel_with_host_model(cursor.clone(), Some("claude"), |service| {
            service.restore_session(
                SessionId::new("cursor-acp-3"),
                Some(crate::domain::model::CursorAgentId::new("bc-restored")),
                None,
            );
        });

    let loaded = client
        .call(
            1,
            "session/load",
            serde_json::json!({"sessionId":"cursor-acp-3", "cwd":"/workspace", "mcpServers":[]}),
        )
        .await;
    expect_result(&loaded);
    let events = cursor.script_stream();
    events
        .send(CursorEvent::Result {
            run_id: CursorRunId::new("run-fake-1"),
            status: RunStatus::Finished,
            text: None,
            duration_ms: None,
            git: None,
        })
        .expect("stream open");
    events.send(CursorEvent::Done).expect("stream open");
    service
        .prompt(&SessionId::new("cursor-acp-3"), "go")
        .await
        .expect("a prompt with an unresolvable restored model still runs");

    let asked = cursor
        .calls()
        .into_iter()
        .find_map(|call| match call {
            CursorCall::CreateRun(_, _, model, _) => Some(model),
            _ => None,
        })
        .expect("the restored agent got a follow-up run");
    assert_eq!(asked, None, "no opinion: Cursor resolves its own default");
}

/// `session/load` restates the client's MCP servers, and a restored session
/// whose agent was never minted applies them when the first prompt creates it.
///
/// The host cannot pass these at restore because it never had them — the list
/// is the client's, and the protocol carries it on load. Before this the
/// restore path pinned the list to empty.
#[tokio::test]
async fn session_load_restores_the_clients_mcp_servers() {
    let cursor = FakeCursor::new();
    let (service, mut client) = serve_over_channel(cursor.clone(), |service| {
        // Restored with *no* agent: the session opened, never prompted, died.
        service.restore_session(SessionId::new("cursor-acp-3"), None, None);
    });

    let loaded = client
        .call(
            1,
            "session/load",
            serde_json::json!({
                "sessionId": "cursor-acp-3",
                "cwd": "/workspace",
                "mcpServers": [
                    {
                        "type": "http",
                        "name": "remote",
                        "url": "https://mcp.example.com",
                        "headers": [],
                    },
                ],
            }),
        )
        .await;
    expect_result(&loaded);

    let events = cursor.script_stream();
    events
        .send(CursorEvent::Result {
            run_id: CursorRunId::new("run-fake-1"),
            status: RunStatus::Finished,
            text: None,
            duration_ms: None,
            git: None,
        })
        .expect("stream open");
    events.send(CursorEvent::Done).expect("stream open");
    service
        .prompt(&SessionId::new("cursor-acp-3"), "go")
        .await
        .expect("prompt runs");

    let calls = cursor.calls();
    let [CursorCall::CreateAgent(_, _, _, servers, _, _)] = calls.as_slice() else {
        panic!("expected one agent creation, got {calls:?}");
    };
    assert_eq!(servers.len(), 1);
    assert_eq!(servers[0].name, "remote");
}

/// A fresh session with nothing pinned still gets the full picker, resting on
/// Cursor's own "Auto" — the gap that used to make the selector unreachable:
/// no current meant no options, and the picker was the only way to set one.
#[tokio::test]
async fn a_session_with_no_choice_rests_the_picker_on_auto() {
    let cursor = FakeCursor::new();
    let mut models = offered_models();
    models.insert(
        0,
        CursorModel {
            id: "default".to_owned(),
            display_name: "Auto".to_owned(),
            variants: vec![ModelVariant {
                params: Vec::new(),
                is_default: true,
            }],
        },
    );
    cursor.script_models(models);
    let (service, mut client) = serve_over_channel(cursor.clone(), |_| {});

    let opened = client
        .call(
            1,
            "session/new",
            serde_json::json!({"cwd": "/workspace", "mcpServers": []}),
        )
        .await;
    let result = expect_result(&opened);
    let option = &result["configOptions"][0];
    assert_eq!(option["currentValue"], "default");
    assert_eq!(
        option["options"].as_array().expect("options").len(),
        3,
        "every offered model is listed, Auto included"
    );
    let session = result["sessionId"]
        .as_str()
        .expect("a session id")
        .to_owned();

    // Auto as the resting value is display, not state: the run still omits
    // `model`, so Cursor resolves the user's own account default rather than
    // being forced onto Auto routing.
    let events = cursor.script_stream();
    events
        .send(CursorEvent::Result {
            run_id: CursorRunId::new("run-fake-1"),
            status: RunStatus::Finished,
            text: None,
            duration_ms: None,
            git: None,
        })
        .expect("stream open");
    events.send(CursorEvent::Done).expect("stream open");
    service
        .prompt(&SessionId::new(session), "go")
        .await
        .expect("prompt runs");
    let asked = cursor
        .calls()
        .into_iter()
        .find_map(|call| match call {
            CursorCall::CreateAgent(_, _, _, _, model, _) => Some(model),
            _ => None,
        })
        .expect("the prompt created an agent");
    assert_eq!(asked, None, "resting on Auto sends no model field");
}

/// Cursor's list without an "Auto" entry leaves no honest resting value, so
/// the picker is withheld rather than rested on a guess.
#[tokio::test]
async fn no_auto_entry_means_no_picker_rather_than_a_guess() {
    let cursor = FakeCursor::new();
    cursor.script_models(offered_models()); // no "default" entry
    let (_service, mut client) = serve_over_channel(cursor, |_| {});

    let opened = client
        .call(
            1,
            "session/new",
            serde_json::json!({"cwd": "/workspace", "mcpServers": []}),
        )
        .await;
    let result = expect_result(&opened);
    assert!(
        result["configOptions"]
            .as_array()
            .is_none_or(|options| options.is_empty()),
        "no resting value, no picker: {result}"
    );
}

#[tokio::test]
async fn load_queues_all_native_history_before_its_response_and_repeats_without_execution() {
    let cursor = FakeCursor::new();
    cursor.script_run_listings(vec![crate::domain::model::RunListing {
        id: CursorRunId::new("old-run"),
        status: RunStatus::Finished,
    }]);
    let tx = cursor.script_raw_stream();
    for event in crate::testing::fixture_records("file_operations.sse") {
        tx.send(event).unwrap();
    }
    drop(tx);
    let (service, mut client) = serve_over_channel(cursor.clone(), |service| {
        service.restore_session(
            SessionId::new("restored"),
            Some(crate::domain::model::CursorAgentId::new("agent")),
            None,
        );
    });
    let mut first = Vec::new();
    for id in [11, 12] {
        client.send(serde_json::json!({"jsonrpc":"2.0", "id":id, "method":"session/load", "params":{"sessionId":"restored", "cwd":"/workspace", "mcpServers":[]}}));
        let mut replay = Vec::new();
        loop {
            let frame = client.next_frame().await;
            if frame.get("id") == Some(&serde_json::json!(id)) {
                expect_result(&frame);
                break;
            }
            assert!(matches!(
                frame["method"].as_str(),
                Some("session/update" | "_session/turn_complete")
            ));
            if frame["params"]["update"]["sessionUpdate"] == "available_commands_update" {
                continue;
            }
            replay.push(
                frame["params"]
                    .get("update")
                    .cloned()
                    .unwrap_or_else(|| frame.clone()),
            );
        }
        assert_eq!(replay[0]["sessionUpdate"], "user_message_chunk");
        assert!(replay.iter().any(|u| u["sessionUpdate"] == "tool_call"));
        assert!(
            replay
                .iter()
                .any(|u| u["sessionUpdate"] == "tool_call_update")
        );
        if id == 11 {
            first = replay;
        } else {
            assert_eq!(first, replay);
        }
    }
    assert!(
        cursor.calls().is_empty(),
        "replay never executes provider actions"
    );
    assert!(service.has_session(&SessionId::new("restored")));
}