Skip to content

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.md
index 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 input
diff --git a/src/providers/cursor/client.rs b/src/providers/cursor/client.rs
index 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.rs
index 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();