Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy
Rust
cursor: expand catalog effort slugs into parameters
ethandeydc7396f275dc
diff --git a/docs/src/content/docs/providers/cursor-agent.md b/docs/src/content/docs/providers/cursor-agent.mdindex a44c2fa..424bec7 100644--- a/docs/src/content/docs/providers/cursor-agent.md+++ b/docs/src/content/docs/providers/cursor-agent.md@@ -40,7 +40,9 @@ Unknown future IDs are accepted through `cursor:<raw-model>`.## Effort mapping-Claude Code's `/effort` selects matching Cursor catalog variants when available. For example, `cursor:gpt-5.5` plus high effort can resolve to `gpt-5.5-high`. Explicit effort suffixes are preserved. Fast suffixes remain when the catalog supports them, and models without effort variants stay unchanged.+Some Cursor list ids are not wire ids. `cursor:claude-sonnet-5-5-medium` is sent as family id `claude-sonnet-5-5` with `context=300k` and `reasoning_effort=medium`. The proxy does this for the families whose catalog stores effort in parameters (`reasoning_effort`, `effort`, or `reasoning`) and includes `context` only when that family's non-max variant has one. `fast` is sent only when the family lists it. Sending `fast` on Claude Sonnet 5.5 makes Cursor return `ERROR_BAD_MODEL_NAME`.++Composer and Grok stay a family id plus the `fast` flag. A trailing `-fast` on Opus is kept. An unknown `cursor:<id>` is forwarded as that id with `fast`. A bare family id uses that family's default effort. This is the non-max parameter set, not the 1m max-mode variant.## Tools and multimodal inputdiff --git a/src/providers/cursor/client.rs b/src/providers/cursor/client.rsindex 1ffd2ac..3626780 100644--- a/src/providers/cursor/client.rs+++ b/src/providers/cursor/client.rs@@ -451,17 +451,20 @@ fn model_parameter(id: &str, value: &str) -> Vec<u8> {parameter}-fn model_message(model: &str, fast: bool) -> Vec<u8> {- let mut out = field_string(1, model);- // grok-4.7's 500k window is max mode on the same id (AvailableModels, 2026-10-13).- if model == "grok-4.7" {+fn model_message(resolved: &CursorModelResolution) -> Vec<u8> {+ let mut out = field_string(1, &resolved.model_id);+ // Grok 4.7 exposes its 500k window through max mode.+ if resolved.model_id == "grok-4.7" {out.extend(field_varint(2, 1));out.extend(field_bytes(3, &model_parameter("context", "500k")));}- out.extend(field_bytes(- 3,- &model_parameter("fast", if fast { "true" } else { "false" }),- ));+ for (id, value) in &resolved.parameters {+ out.extend(field_bytes(3, &model_parameter(id, value)));+ }+ if resolved.send_fast {+ let value = if resolved.fast { "true" } else { "false" };+ out.extend(field_bytes(3, &model_parameter("fast", value)));+ }out}@@ -515,13 +518,13 @@ fn build_run_frames(request.extend(field_string(5, &conversation_id));request.extend(field_bytes(9,- &model_message(&resolved.model_id, resolved.fast),+ &model_message(resolved),));request.extend(field_varint(12, 0));request.extend(field_bytes(14, &field_string(1, "default")));request.extend(field_bytes(14,- &model_message(&resolved.model_id, resolved.fast),+ &model_message(resolved),));request.extend(field_string(16, &conversation_id));let first = encode_connect_frame(field_bytes(1, &request), 0);@@ -736,7 +739,7 @@ mod model_message_tests {#[test]fn grok_4_7_requests_max_mode_500k() {- let msg = model_message("grok-4.7", false);+ let msg = model_message(&wire("grok-4.7"));let text = String::from_utf8_lossy(&msg);assert!(text.contains("grok-4.7"));assert!(text.contains("context"));@@ -748,11 +751,36 @@ mod model_message_tests {#[test]fn other_models_do_not_request_max_mode() {- let msg = model_message("composer-2.5", true);+ let msg = model_message(&wire("composer-2.5-fast"));let text = String::from_utf8_lossy(&msg);assert!(text.contains("composer-2.5"));assert!(text.contains("true"));assert!(!text.contains("500k"));assert!(!msg.windows(2).any(|pair| pair == [0x10, 0x01]));}++ fn wire(model: &str) -> CursorModelResolution {+ crate::providers::cursor::model::resolve_cursor_model(&format!("cursor:{model}")).unwrap()+ }++ #[test]+ fn sonnet_5_5_medium_omits_fast() {+ let msg = model_message(&wire("claude-sonnet-5-5-medium"));+ let text = String::from_utf8_lossy(&msg);+ assert!(text.contains("claude-sonnet-5-5"));+ assert!(text.contains("reasoning_effort"));+ assert!(text.contains("medium"));+ assert!(text.contains("300k"));+ assert!(!text.contains("fast"));+ }++ #[test]+ fn composer_fast_still_sends_fast() {+ let msg = model_message(&wire("composer-2.5-fast"));+ let text = String::from_utf8_lossy(&msg);+ assert!(text.contains("composer-2.5"));+ assert!(text.contains("fast"));+ assert!(text.contains("true"));+ assert!(!text.contains("300k"));+ }}diff --git a/src/providers/cursor/model.rs b/src/providers/cursor/model.rsindex 54a1224..238cebc 100644--- a/src/providers/cursor/model.rs+++ b/src/providers/cursor/model.rs@@ -27,10 +27,195 @@ impl CursorAgentMode {}}-fn resolve_wire_model(raw: &str) -> (String, bool) {- raw.strip_suffix("-fast")- .map(|model| (model.to_string(), true))- .unwrap_or_else(|| (raw.to_string(), false))+/// 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> {@@ -42,11 +227,13 @@ pub fn resolve_cursor_model(model: &str) -> Result<CursorModelResolution, String("cursor:", CursorAgentMode::Agent),] {if let Some(raw) = model.strip_prefix(prefix) {- let (model_id, fast) = resolve_wire_model(raw);+ let resolved = resolve_wire_model(raw);return Ok(CursorModelResolution {- model_id,+ model_id: resolved.model_id,mode,- fast,+ fast: resolved.fast,+ parameters: resolved.parameters,+ send_fast: resolved.send_fast,});}}@@ -65,11 +252,7 @@ pub fn resolve_cursor_model(model: &str) -> Result<CursorModelResolution, String));}};- Ok(CursorModelResolution {- model_id: model_id.to_string(),- mode,- fast,- })+ Ok(resolution(model_id, mode, fast))}#[derive(Debug, Clone)]@@ -77,6 +260,10 @@ 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> {@@ -153,6 +340,52 @@ mod tests {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();