Use server-driven ModelCapabilities for Cursor traits

Replace the hardcoded client-side CURSOR_MODEL_CAPABILITY_BY_FAMILY map
with server-provided ModelCapabilities, matching the Codex/Claude pattern.

- Add CursorProvider snapshot service with BUILT_IN_MODELS and per-model
  capabilities; register it in ProviderRegistry alongside Codex/Claude.
- Delete CursorTraitsPicker and route Cursor through the generic
  TraitsPicker, adding cursor support for the reasoning/effort key.
- Add normalizeCursorModelOptionsWithCapabilities to providerModels.

Made-with: Cursor

Author: juliusmarminge

apps/server/src/provider/Layers/CursorProvider.ts

@@ -8,17 +8,21 @@ import { Effect, Equal, Layer, PubSub, Ref, Stream } from "effect";
 
 import { ClaudeProviderLive } from "./ClaudeProvider";
 import { CodexProviderLive } from "./CodexProvider";
+import { CursorProviderLive } from "./CursorProvider";
 import type { ClaudeProviderShape } from "../Services/ClaudeProvider";
 import { ClaudeProvider } from "../Services/ClaudeProvider";
 import type { CodexProviderShape } from "../Services/CodexProvider";
 import { CodexProvider } from "../Services/CodexProvider";
+import type { CursorProviderShape } from "../Services/CursorProvider";
+import { CursorProvider } from "../Services/CursorProvider";
 import { ProviderRegistry, type ProviderRegistryShape } from "../Services/ProviderRegistry";
 
 const loadProviders = (
   codexProvider: CodexProviderShape,
   claudeProvider: ClaudeProviderShape,
-): Effect.Effect<readonly [ServerProvider, ServerProvider]> =>
-  Effect.all([codexProvider.getSnapshot, claudeProvider.getSnapshot], {
+  cursorProvider: CursorProviderShape,
+): Effect.Effect<readonly [ServerProvider, ServerProvider, ServerProvider]> =>
+  Effect.all([codexProvider.getSnapshot, claudeProvider.getSnapshot, cursorProvider.getSnapshot], {
     concurrency: "unbounded",
   });
 
@@ -32,18 +36,19 @@ export const ProviderRegistryLive = Layer.effect(
   Effect.gen(function* () {
     const codexProvider = yield* CodexProvider;
     const claudeProvider = yield* ClaudeProvider;
+    const cursorProvider = yield* CursorProvider;
     const changesPubSub = yield* Effect.acquireRelease(
       PubSub.unbounded<ReadonlyArray<ServerProvider>>(),
       PubSub.shutdown,
     );
     const providersRef = yield* Ref.make<ReadonlyArray<ServerProvider>>(
-      yield* loadProviders(codexProvider, claudeProvider),
+      yield* loadProviders(codexProvider, claudeProvider, cursorProvider),
     );
 
     const syncProviders = (options?: { readonly publish?: boolean }) =>
       Effect.gen(function* () {
         const previousProviders = yield* Ref.get(providersRef);
-        const providers = yield* loadProviders(codexProvider, claudeProvider);
+        const providers = yield* loadProviders(codexProvider, claudeProvider, cursorProvider);
         yield* Ref.set(providersRef, providers);
 
         if (options?.publish !== false && haveProvidersChanged(previousProviders, providers)) {
@@ -59,6 +64,9 @@ export const ProviderRegistryLive = Layer.effect(
     yield* Stream.runForEach(claudeProvider.streamChanges, () => syncProviders()).pipe(
       Effect.forkScoped,
     );
+    yield* Stream.runForEach(cursorProvider.streamChanges, () => syncProviders()).pipe(
+      Effect.forkScoped,
+    );
 
     return {
       getProviders: syncProviders({ publish: false }).pipe(
@@ -74,10 +82,14 @@ export const ProviderRegistryLive = Layer.effect(
             case "claudeAgent":
               yield* claudeProvider.refresh;
               break;
+            case "cursor":
+              yield* cursorProvider.refresh;
+              break;
             default:
-              yield* Effect.all([codexProvider.refresh, claudeProvider.refresh], {
-                concurrency: "unbounded",
-              });
+              yield* Effect.all(
+                [codexProvider.refresh, claudeProvider.refresh, cursorProvider.refresh],
+                { concurrency: "unbounded" },
+              );
               break;
           }
           return yield* syncProviders();
@@ -90,4 +102,8 @@ export const ProviderRegistryLive = Layer.effect(
       },
     } satisfies ProviderRegistryShape;
   }),
-).pipe(Layer.provideMerge(CodexProviderLive), Layer.provideMerge(ClaudeProviderLive));
+).pipe(
+  Layer.provideMerge(CodexProviderLive),
+  Layer.provideMerge(ClaudeProviderLive),
+  Layer.provideMerge(CursorProviderLive),
+);

apps/server/src/provider/Layers/ProviderRegistry.ts

@@ -0,0 +1,9 @@
+import { ServiceMap } from "effect";
+
+import type { ServerProviderShape } from "./ServerProvider";
+
+export interface CursorProviderShape extends ServerProviderShape {}
+
+export class CursorProvider extends ServiceMap.Service<CursorProvider, CursorProviderShape>()(
+  "t3/provider/Services/CursorProvider",
+) {}

apps/server/src/provider/Services/CursorProvider.ts

@@ -6,7 +6,6 @@ import { afterEach, describe, expect, it, vi } from "vitest";
 import { render } from "vitest-browser-react";
 
 import { CompactComposerControlsMenu } from "./CompactComposerControlsMenu";
-import { CursorTraitsMenuContent } from "./CursorTraitsPicker";
 import { TraitsMenuContent } from "./TraitsPicker";
 import { useComposerDraftStore } from "../../composerDraftStore";
 
@@ -109,27 +108,42 @@ async function mountMenu(props?: { modelSelection?: ModelSelection; prompt?: str
               },
             },
           ]
-        : [];
+        : provider === "cursor"
+          ? [
+              {
+                slug: "gpt-5.3-codex",
+                name: "Codex 5.3",
+                isCustom: false,
+                capabilities: {
+                  reasoningEffortLevels: [
+                    { value: "low", label: "Low" },
+                    { value: "normal", label: "Normal", isDefault: true },
+                    { value: "high", label: "High" },
+                    { value: "xhigh", label: "Extra high" },
+                  ],
+                  supportsFastMode: true,
+                  supportsThinkingToggle: false,
+                  promptInjectedEffortLevels: [],
+                },
+              },
+            ]
+          : [];
   const screen = await render(
     <CompactComposerControlsMenu
       activePlan={false}
       interactionMode="default"
       planSidebarOpen={false}
       runtimeMode="approval-required"
       traitsMenuContent={
-        provider === "cursor" ? (
-          <CursorTraitsMenuContent threadId={threadId} model={model} cursorModelOptions={null} />
-        ) : (
-          <TraitsMenuContent
-            provider={provider}
-            models={models}
-            threadId={threadId}
-            model={model}
-            prompt={props?.prompt ?? ""}
-            modelOptions={providerOptions}
-            onPromptChange={onPromptChange}
-          />
-        )
+        <TraitsMenuContent
+          provider={provider}
+          models={models}
+          threadId={threadId}
+          model={model}
+          prompt={props?.prompt ?? ""}
+          modelOptions={providerOptions}
+          onPromptChange={onPromptChange}
+        />
       }
       onToggleInteractionMode={vi.fn()}
       onTogglePlanSidebar={vi.fn()}