Skip to content

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

Rust

map claude effort to cursor model variants

Raine Virta352b549931af
diff --git a/README.md b/README.md
index 941d13b..3450812 100644
--- a/README.md
+++ b/README.md
@@ -339,6 +339,15 @@ The catalog advertised by `/v1/models` is generated from
`cursor-agent --list-models`; unknown future ids are still accepted with
`cursor:<raw-model>`.
+Claude Code's `/effort` setting is mapped onto Cursor catalog ids when the
+selected Cursor model exposes matching effort variants. For example,
+`ANTHROPIC_MODEL=cursor:gpt-5.5` plus `/effort high` requests
+`gpt-5.5-high`, while `/effort max` picks the strongest available catalog
+variant such as `xhigh`, `extra-high`, or `high`. Explicit effort model ids
+such as `cursor:gpt-5.5-low` are respected as-is, `-fast` is preserved when
+available, and models without effort variants (for example
+`cursor:gemini-3.1-pro` in the captured catalog) are left unchanged.
+
Plan mode can also be selected per request with metadata:
```json
diff --git a/src/providers/cursor/translate/model.test.ts b/src/providers/cursor/translate/model.test.ts
index 19fe1fa..e59f3a6 100644
--- a/src/providers/cursor/translate/model.test.ts
+++ b/src/providers/cursor/translate/model.test.ts
@@ -45,6 +45,77 @@ describe("Cursor model selection", () => {
expect(selected.requestedModel).toEqual({ modelId: "gpt-5.5-high-fast" });
});
+ it("maps Claude effort onto Cursor catalog effort variants", () => {
+ expect(resolveCursorModel({
+ model: "cursor:gpt-5.5",
+ metadata: undefined,
+ output_config: { effort: "low" },
+ }).requestedModel).toEqual({ modelId: "gpt-5.5-low" });
+ expect(resolveCursorModel({
+ model: "cursor:gpt-5.5",
+ metadata: undefined,
+ output_config: { effort: "medium" },
+ }).requestedModel).toEqual({ modelId: "gpt-5.5-medium" });
+ expect(resolveCursorModel({
+ model: "cursor:gpt-5.5",
+ metadata: undefined,
+ output_config: { effort: "high" },
+ }).requestedModel).toEqual({ modelId: "gpt-5.5-high" });
+ expect(resolveCursorModel({
+ model: "cursor:gpt-5.5",
+ metadata: undefined,
+ output_config: { effort: "max" },
+ }).requestedModel).toEqual({ modelId: "gpt-5.5-extra-high" });
+ });
+
+ it("preserves fast mode when applying Cursor effort variants", () => {
+ expect(resolveCursorModel({
+ model: "cursor:gpt-5.5-fast",
+ metadata: undefined,
+ output_config: { effort: "high" },
+ }).requestedModel).toEqual({ modelId: "gpt-5.5-high-fast" });
+ });
+
+ it("maps max effort to Cursor xhigh when max is unavailable", () => {
+ expect(resolveCursorModel({
+ model: "cursor:gpt-5.2",
+ metadata: undefined,
+ output_config: { effort: "max" },
+ }).requestedModel).toEqual({ modelId: "gpt-5.2-xhigh" });
+ });
+
+ it("applies effort independently of Cursor mode prefixes", () => {
+ expect(resolveCursorModel({
+ model: "cursor-plan:claude-opus-4-8",
+ metadata: undefined,
+ output_config: { effort: "max" },
+ })).toEqual({
+ mode: "AGENT_MODE_PLAN",
+ requestedModel: { modelId: "claude-opus-4-8-max" },
+ });
+ expect(resolveCursorModel({
+ model: "cursor-ask:claude-opus-4-8-thinking",
+ metadata: undefined,
+ output_config: { effort: "high" },
+ })).toEqual({
+ mode: "AGENT_MODE_ASK",
+ requestedModel: { modelId: "claude-opus-4-8-thinking-high" },
+ });
+ });
+
+ it("does not override explicit Cursor effort ids or models without effort variants", () => {
+ expect(resolveCursorModel({
+ model: "cursor:gpt-5.5-low",
+ metadata: undefined,
+ output_config: { effort: "max" },
+ }).requestedModel).toEqual({ modelId: "gpt-5.5-low" });
+ expect(resolveCursorModel({
+ model: "cursor:gemini-3.1-pro",
+ metadata: undefined,
+ output_config: { effort: "high" },
+ }).requestedModel).toEqual({ modelId: "gemini-3.1-pro" });
+ });
+
it("supports prefixed plan and ask variants for catalog ids", () => {
expect(resolveCursorModel({ model: "cursor-plan:gpt-5.5-high", metadata: undefined })).toEqual({
mode: "AGENT_MODE_PLAN",
diff --git a/src/providers/cursor/translate/model.ts b/src/providers/cursor/translate/model.ts
index 4f2455b..d5c0f78 100644
--- a/src/providers/cursor/translate/model.ts
+++ b/src/providers/cursor/translate/model.ts
@@ -7,6 +7,8 @@ export interface CursorModelSelection {
mode: CursorAgentMode;
}
+type AnthropicEffort = NonNullable<AnthropicRequest["output_config"]>["effort"];
+
const LEGACY_CURSOR_MODELS = [
"cursor",
"cursor-agent",
@@ -36,12 +38,13 @@ export function isCursorModel(model: string): boolean {
return CURSOR_SUPPORTED_MODELS.has(model) || CURSOR_MODEL_PREFIXES.some((p) => model.startsWith(p.prefix));
}
-export function resolveCursorModel(req: Pick<AnthropicRequest, "model" | "metadata">): CursorModelSelection {
+export function resolveCursorModel(req: Pick<AnthropicRequest, "model" | "metadata" | "output_config">): CursorModelSelection {
let mode = modeFromMetadata(req.metadata);
+ const effort = req.output_config?.effort;
const prefixed = splitCursorModelPrefix(req.model);
if (prefixed) {
return {
- requestedModel: parseRawCursorModel(prefixed.raw),
+ requestedModel: parseRawCursorModel(applyCursorEffort(prefixed.raw, effort)),
mode: prefixed.mode ?? mode ?? "AGENT_MODE_AGENT",
};
}
@@ -80,6 +83,62 @@ function parseRawCursorModel(raw: string): CursorModelRequest {
return { modelId: raw };
}
+const EFFORT_SUFFIXES = [
+ "extra-high",
+ "medium",
+ "xhigh",
+ "high",
+ "low",
+ "max",
+ "none",
+] as const;
+
+function applyCursorEffort(raw: string, effort: AnthropicEffort | undefined): string {
+ if (!effort) return raw;
+ const { modelId, fast } = splitFastSuffix(raw);
+ if (hasEffortSuffix(modelId)) return raw;
+
+ const targetBase = findCursorEffortVariant(modelId, effort);
+ if (!targetBase) return raw;
+ if (!fast) return targetBase;
+
+ const fastTarget = `${targetBase}-fast`;
+ return CURSOR_AGENT_MODEL_ID_SET.has(fastTarget) ? fastTarget : `${targetBase}-fast`;
+}
+
+function findCursorEffortVariant(modelId: string, effort: AnthropicEffort): string | undefined {
+ for (const suffix of cursorEffortSuffixCandidates(effort)) {
+ const candidate = `${modelId}-${suffix}`;
+ if (CURSOR_AGENT_MODEL_ID_SET.has(candidate)) return candidate;
+ }
+ return undefined;
+}
+
+function cursorEffortSuffixCandidates(effort: AnthropicEffort): readonly string[] {
+ switch (effort) {
+ case "low":
+ return ["low"];
+ case "medium":
+ return ["medium"];
+ case "high":
+ return ["high", "extra-high", "xhigh"];
+ case "max":
+ return ["max", "xhigh", "extra-high", "high"];
+ default:
+ return [];
+ }
+}
+
+function hasEffortSuffix(modelId: string): boolean {
+ return EFFORT_SUFFIXES.some((suffix) => modelId.endsWith(`-${suffix}`));
+}
+
+function splitFastSuffix(raw: string): { modelId: string; fast: boolean } {
+ return raw.endsWith("-fast")
+ ? { modelId: raw.slice(0, -"-fast".length), fast: true }
+ : { modelId: raw, fast: false };
+}
+
function splitCursorModelPrefix(model: string): { raw: string; mode?: CursorAgentMode } | undefined {
for (const p of CURSOR_MODEL_PREFIXES) {
if (model.startsWith(p.prefix)) return { raw: model.slice(p.prefix.length), mode: p.mode };