copilot-sdk 2.0.0

Rust SDK for programmatic control of the GitHub Copilot CLI via JSON-RPC.
#![cfg(test)]
#![allow(clippy::unwrap_used)]

use copilot_sdk::Error;
use copilot_sdk::rpc::{
    CatalogClientContract, CatalogSearchRequest, ClientRpcCatalog, ClientRpcMcp, ClientRpcSessions,
    McpPlanInstallRequest, McpPlanInstallSource, McpPlanInstallSourceCandidate,
    McpPlanInstallSourceCandidateKind, PermissionsSetRequiredRequest, SessionRpcPermissions,
    SessionUpdateInferenceOptions, SessionUpdateOptionsParams, SessionsCloseRequest,
};
use serde_json::json;

#[test]
fn grouped_options_update_preserves_default_provider_omission_selection_and_clear() {
    for (default_provider, inference) in [
        (None, json!({})),
        (Some(None), json!({"defaultProvider": null})),
        (
            Some(Some("gateway".to_owned())),
            json!({"defaultProvider": "gateway"}),
        ),
    ] {
        let params = SessionUpdateOptionsParams {
            inference: Some(SessionUpdateInferenceOptions {
                default_provider: default_provider.clone(),
                ..Default::default()
            }),
            ..Default::default()
        };
        let expected = json!({"inference": inference});
        assert_eq!(serde_json::to_value(params).unwrap(), expected);
        let decoded: SessionUpdateOptionsParams = serde_json::from_value(expected).unwrap();
        assert_eq!(
            decoded.inference.unwrap().default_provider,
            default_provider
        );
    }
}

#[test]
fn permission_request_preserves_provider_scope_and_explicit_false() {
    let request = PermissionsSetRequiredRequest {
        required: false,
        provider_id: Some("provider".to_string()),
    };
    assert_eq!(
        serde_json::to_value(request).unwrap(),
        json!({"required": false, "providerId": "provider"})
    );
}

#[test]
fn session_close_preserves_absent_and_explicit_detach_values() {
    for detach in [None, Some(false), Some(true)] {
        let request = SessionsCloseRequest {
            session_id: "session".into(),
            detach_session_end_hooks: detach,
        };
        let wire = serde_json::to_value(request).unwrap();
        assert_eq!(wire["sessionId"], "session");
        assert_eq!(
            wire.get("detachSessionEndHooks"),
            detach.map(|v| json!(v)).as_ref()
        );
    }
}

fn contract() -> CatalogClientContract {
    CatalogClientContract {
        protocol_version: 3,
        required_capabilities: vec!["mcp-install-planning".to_string()],
    }
}

fn candidate() -> McpPlanInstallSource {
    McpPlanInstallSource::Candidate(McpPlanInstallSourceCandidate {
        candidate_handle: "candidate".to_string(),
        kind: McpPlanInstallSourceCandidateKind::Candidate,
        search_id: "search".to_string(),
    })
}

#[test]
fn catalog_requests_include_policy_scope_without_an_extended_options_type() {
    let plan = McpPlanInstallRequest {
        contract: contract(),
        policy_session_id: Some("session".to_string()),
        scope: None,
        source: candidate(),
    };
    let search = CatalogSearchRequest {
        contract: contract(),
        policy_session_id: Some("session".to_string()),
        query: "catalogue query".to_string(),
        limit: Some(4),
        ..Default::default()
    };
    assert_eq!(
        serde_json::to_value(plan).unwrap()["policySessionId"],
        "session"
    );
    let search = serde_json::to_value(search).unwrap();
    assert_eq!(search["policySessionId"], "session");
    assert_eq!(search["limit"], 4);
    assert!(search.get("categories").is_none());
}

#[allow(dead_code)]
async fn request_entry_points_compile(
    permissions: SessionRpcPermissions<'_>,
    sessions: ClientRpcSessions<'_>,
    mcp: ClientRpcMcp<'_>,
    catalog: ClientRpcCatalog<'_>,
) -> Result<(), Error> {
    permissions
        .set_required(PermissionsSetRequiredRequest {
            required: false,
            provider_id: Some("provider".to_string()),
        })
        .await?;
    sessions
        .close(SessionsCloseRequest {
            session_id: "session".into(),
            detach_session_end_hooks: Some(true),
        })
        .await?;
    mcp.plan_install(McpPlanInstallRequest {
        contract: contract(),
        policy_session_id: Some("session".to_string()),
        scope: None,
        source: candidate(),
    })
    .await?;
    catalog
        .search(CatalogSearchRequest {
            contract: contract(),
            query: "catalogue query".to_string(),
            ..Default::default()
        })
        .await?;
    Ok(())
}