Skip to content

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

Rust
12.5 KB
Raw Blame
/// Cursor model catalog resolves incoming model names to Cursor wire IDs.
pub const CURSOR_LEGACY_MODELS: &[&str] = &[
    "cursor",
    "cursor-agent",
    "cursor-composer",
    "cursor-composer-fast",
    "cursor-plan",
    "cursor-ask",
    "composer-2.5",
    "composer-2.5-fast",
];

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CursorAgentMode {
    Agent,
    Plan,
    Ask,
}

impl CursorAgentMode {
    pub fn as_str(&self) -> &'static str {
        match self {
            CursorAgentMode::Agent => "AGENT_MODE_AGENT",
            CursorAgentMode::Plan => "AGENT_MODE_PLAN",
            CursorAgentMode::Ask => "AGENT_MODE_ASK",
        }
    }
}

/// Cursor list ids whose effort lives in parameters, not in the model id.
///
/// `claude-sonnet-5-5-medium` is not a wire id. The wire id is
/// `claude-sonnet-5-5` with `context=300k` and `reasoning_effort=medium`.
/// Sending `fast` on that model makes Cursor return ERROR_BAD_MODEL_NAME.
struct ParameterFamily {
    id: &'static str,
    effort_key: &'static str,
    default_effort: &'static str,
    context: Option<&'static str>,
    thinking: bool,
    send_fast: bool,
}

const PARAMETER_FAMILIES: &[ParameterFamily] = &[
    ParameterFamily {
        id: "claude-sonnet-5-5",
        effort_key: "reasoning_effort",
        default_effort: "high",
        context: Some("300k"),
        thinking: false,
        send_fast: false,
    },
    ParameterFamily {
        id: "claude-opus-5-5",
        effort_key: "effort",
        default_effort: "medium",
        context: Some("300k"),
        thinking: false,
        send_fast: true,
    },
    ParameterFamily {
        id: "claude-fable-5-1",
        effort_key: "effort",
        default_effort: "high",
        context: Some("300k"),
        thinking: true,
        send_fast: false,
    },
    ParameterFamily {
        id: "claude-sonnet-5",
        effort_key: "effort",
        default_effort: "high",
        context: Some("300k"),
        thinking: true,
        send_fast: false,
    },
    ParameterFamily {
        id: "claude-fable-5",
        effort_key: "effort",
        default_effort: "high",
        context: Some("300k"),
        thinking: true,
        send_fast: false,
    },
    ParameterFamily {
        id: "gemini-3.8-flash",
        effort_key: "reasoning_effort",
        default_effort: "high",
        context: None,
        thinking: false,
        send_fast: false,
    },
    ParameterFamily {
        id: "gemini-4-argon",
        effort_key: "reasoning_effort",
        default_effort: "medium",
        context: None,
        thinking: false,
        send_fast: false,
    },
    ParameterFamily {
        id: "muse-spark-1.3",
        effort_key: "effort",
        default_effort: "high",
        context: Some("300k"),
        thinking: false,
        send_fast: false,
    },
    ParameterFamily {
        id: "muse-wonder-1.0",
        effort_key: "reasoning_effort",
        default_effort: "high",
        context: Some("300k"),
        thinking: false,
        send_fast: false,
    },
    ParameterFamily {
        id: "kimi-k3",
        effort_key: "reasoning",
        default_effort: "max",
        context: None,
        thinking: false,
        send_fast: false,
    },
];

const EFFORTS: &[&str] = &["low", "medium", "high", "xhigh", "max"];

struct ResolvedWire {
    model_id: String,
    fast: bool,
    parameters: Vec<(String, String)>,
    send_fast: bool,
}

fn is_effort(value: &str) -> bool {
    EFFORTS.contains(&value)
}

fn matches_family(raw: &str, id: &str) -> bool {
    raw == id
        || raw
            .strip_prefix(id)
            .is_some_and(|rest| rest.starts_with('-'))
}

fn find_family(raw: &str) -> Option<&'static ParameterFamily> {
    PARAMETER_FAMILIES
        .iter()
        .filter(|family| matches_family(raw, family.id))
        .max_by_key(|family| family.id.len())
}

/// Split a list id such as `claude-sonnet-5-5-medium` into the wire id and
/// the parameters Cursor's catalog actually stores on that variant.
fn parameterized_model(raw: &str) -> Option<ResolvedWire> {
    let family = find_family(raw)?;
    let rest = raw[family.id.len()..].trim_start_matches('-');
    let (thinking, effort) = if family.thinking {
        if let Some(after) = rest.strip_prefix("thinking") {
            let after = after.trim_start_matches('-');
            let effort = if after.is_empty() {
                family.default_effort
            } else {
                after
            };
            (Some("true"), effort)
        } else if rest.is_empty() {
            (Some("true"), family.default_effort)
        } else {
            (Some("false"), rest)
        }
    } else if rest.is_empty() {
        (None, family.default_effort)
    } else {
        (None, rest)
    };
    if !is_effort(effort) {
        return None;
    }
    let mut parameters = Vec::new();
    if let Some(thinking) = thinking {
        parameters.push(("thinking".to_string(), thinking.to_string()));
    }
    if let Some(context) = family.context {
        parameters.push(("context".to_string(), context.to_string()));
    }
    parameters.push((family.effort_key.to_string(), effort.to_string()));
    Some(ResolvedWire {
        model_id: family.id.to_string(),
        fast: false,
        parameters,
        send_fast: family.send_fast,
    })
}

fn resolve_wire_model(raw: &str) -> ResolvedWire {
    let (stripped, fast) = match raw.strip_suffix("-fast") {
        Some(model) => (model.to_string(), true),
        None => (raw.to_string(), false),
    };
    if let Some(mut resolved) = parameterized_model(&stripped) {
        resolved.fast = fast;
        return resolved;
    }
    ResolvedWire {
        model_id: stripped,
        fast,
        parameters: Vec::new(),
        send_fast: true,
    }
}

fn resolution(model_id: &str, mode: CursorAgentMode, fast: bool) -> CursorModelResolution {
    CursorModelResolution {
        model_id: model_id.to_string(),
        mode,
        fast,
        parameters: Vec::new(),
        send_fast: true,
    }
}

pub fn resolve_cursor_model(model: &str) -> Result<CursorModelResolution, String> {
    let model = model.trim();
    for (prefix, mode) in [
        ("cursor-agent:", CursorAgentMode::Agent),
        ("cursor-plan:", CursorAgentMode::Plan),
        ("cursor-ask:", CursorAgentMode::Ask),
        ("cursor:", CursorAgentMode::Agent),
    ] {
        if let Some(raw) = model.strip_prefix(prefix) {
            let resolved = resolve_wire_model(raw);
            return Ok(CursorModelResolution {
                model_id: resolved.model_id,
                mode,
                fast: resolved.fast,
                parameters: resolved.parameters,
                send_fast: resolved.send_fast,
            });
        }
    }

    let (model_id, mode, fast) = match model {
        "cursor" | "cursor-agent" => ("default", CursorAgentMode::Agent, false),
        "cursor-plan" => ("default", CursorAgentMode::Plan, false),
        "cursor-ask" => ("default", CursorAgentMode::Ask, false),
        "cursor-composer" | "composer-2.5" => ("composer-2.5", CursorAgentMode::Agent, false),
        "cursor-composer-fast" | "composer-2.5-fast" => {
            ("composer-2.5", CursorAgentMode::Agent, true)
        }
        _ => {
            return Err(format!(
                "unknown cursor model: {model}. Supported: cursor:<id>, cursor-plan:<id>, cursor-ask:<id>, cursor-agent"
            ));
        }
    };
    Ok(resolution(model_id, mode, fast))
}

#[derive(Debug, Clone)]
pub struct CursorModelResolution {
    pub model_id: String,
    pub mode: CursorAgentMode,
    pub fast: bool,
    /// Catalog parameters other than `fast`. `fast` stays on `send_fast`.
    pub parameters: Vec<(String, String)>,
    /// When false, the model has no `fast` parameter and sending one is a bad model name.
    pub send_fast: bool,
}

pub fn cursor_supported_models() -> Vec<String> {
    let mut out: Vec<String> = CURSOR_LEGACY_MODELS
        .iter()
        .map(|model| (*model).to_string())
        .collect();
    out.sort_unstable();
    out
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn resolve_legacy_cursor() {
        let resolution = resolve_cursor_model("cursor").unwrap();
        assert_eq!(resolution.model_id, "default");
        assert_eq!(resolution.mode, CursorAgentMode::Agent);
    }

    #[test]
    fn resolve_legacy_cursor_agent() {
        let resolution = resolve_cursor_model("cursor-agent").unwrap();
        assert_eq!(resolution.model_id, "default");
        assert_eq!(resolution.mode, CursorAgentMode::Agent);
    }

    #[test]
    fn resolve_legacy_cursor_plan() {
        let resolution = resolve_cursor_model("cursor-plan").unwrap();
        assert_eq!(resolution.model_id, "default");
        assert_eq!(resolution.mode, CursorAgentMode::Plan);
    }

    #[test]
    fn resolve_legacy_cursor_ask() {
        let resolution = resolve_cursor_model("cursor-ask").unwrap();
        assert_eq!(resolution.model_id, "default");
        assert_eq!(resolution.mode, CursorAgentMode::Ask);
    }

    #[test]
    fn resolve_prefixed_cursor() {
        let resolution = resolve_cursor_model("cursor:gpt-5.5").unwrap();
        assert_eq!(resolution.model_id, "gpt-5.5");
        assert_eq!(resolution.mode, CursorAgentMode::Agent);
    }

    #[test]
    fn resolve_prefixed_cursor_plan() {
        let resolution = resolve_cursor_model("cursor-plan:gpt-5.5").unwrap();
        assert_eq!(resolution.model_id, "gpt-5.5");
        assert_eq!(resolution.mode, CursorAgentMode::Plan);
    }

    #[test]
    fn resolve_prefixed_cursor_ask() {
        let resolution = resolve_cursor_model("cursor-ask:gpt-5.5").unwrap();
        assert_eq!(resolution.model_id, "gpt-5.5");
        assert_eq!(resolution.mode, CursorAgentMode::Ask);
    }

    #[test]
    fn resolve_prefixed_cursor_agent() {
        let resolution = resolve_cursor_model("cursor-agent:gpt-5.5").unwrap();
        assert_eq!(resolution.model_id, "gpt-5.5");
        assert_eq!(resolution.mode, CursorAgentMode::Agent);
    }

    #[test]
    fn resolve_unknown_model_errors() {
        assert!(resolve_cursor_model("unknown-model").is_err());
    }

    #[test]
    fn sonnet_5_5_medium_uses_catalog_parameters() {
        let resolution = resolve_cursor_model("cursor:claude-sonnet-5-5-medium").unwrap();
        assert_eq!(resolution.model_id, "claude-sonnet-5-5");
        assert!(!resolution.fast);
        assert!(!resolution.send_fast);
        assert_eq!(
            resolution.parameters,
            vec![
                ("context".to_string(), "300k".to_string()),
                ("reasoning_effort".to_string(), "medium".to_string()),
            ]
        );
    }

    #[test]
    fn opus_medium_fast_keeps_fast_and_effort() {
        let resolution = resolve_cursor_model("cursor:claude-opus-5-5-medium-fast").unwrap();
        assert_eq!(resolution.model_id, "claude-opus-5-5");
        assert!(resolution.fast);
        assert!(resolution.send_fast);
        assert!(
            resolution
                .parameters
                .iter()
                .any(|(key, value)| key == "effort" && value == "medium")
        );
        assert!(
            resolution
                .parameters
                .iter()
                .any(|(key, value)| key == "context" && value == "300k")
        );
    }

    #[test]
    fn fable_high_is_not_the_thinking_variant() {
        let plain = resolve_cursor_model("cursor:claude-fable-5-1-high").unwrap();
        assert_eq!(plain.model_id, "claude-fable-5-1");
        assert!(
            plain
                .parameters
                .iter()
                .any(|(key, value)| key == "thinking" && value == "false")
        );
        let thinking = resolve_cursor_model("cursor:claude-fable-5-1-thinking-high").unwrap();
        assert!(
            thinking
                .parameters
                .iter()
                .any(|(key, value)| key == "thinking" && value == "true")
        );
    }

    #[test]
    fn resolve_composer_models() {
        let regular = resolve_cursor_model("composer-2.5").unwrap();
        assert_eq!(regular.mode, CursorAgentMode::Agent);
        assert_eq!(regular.model_id, "composer-2.5");
        assert!(!regular.fast);

        let fast = resolve_cursor_model("composer-2.5-fast").unwrap();
        assert_eq!(fast.mode, CursorAgentMode::Agent);
        assert_eq!(fast.model_id, "composer-2.5");
        assert!(fast.fast);
    }

    #[test]
    fn supported_models_includes_all_legacy() {
        let models = cursor_supported_models();
        for model in CURSOR_LEGACY_MODELS {
            assert!(models.contains(&model.to_string()), "missing {model}");
        }
    }
}