pi-provider-cursor-ask 0.1.0

package/src/models/cost.ts

@@ -0,0 +1,126 @@
+/**
+ * Model token pricing and cost estimation table.
+ */
+
+export interface ModelCost {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+}
+
+export const MODEL_COST_TABLE: Record<string, ModelCost> = {
+  "claude-4-sonnet": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  "claude-4.5-haiku": { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 },
+  "claude-4.5-opus": { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
+  "claude-4.5-sonnet": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  "claude-4.6-opus": { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
+  "claude-4.6-sonnet": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  "claude-fable-5": { input: 10, output: 50, cacheRead: 1, cacheWrite: 12.5 },
+  "claude-fable-5-1": { input: 10, output: 50, cacheRead: 0.25, cacheWrite: 12.5 },
+  "claude-opus-4-6": { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
+  "claude-opus-5": { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
+  "claude-sonnet-5": { input: 2, output: 10, cacheRead: 0.2, cacheWrite: 2.5 },
+  "composer-1": { input: 1.25, output: 10, cacheRead: 0.125, cacheWrite: 0 },
+  "composer-1.5": { input: 3.5, output: 17.5, cacheRead: 0.35, cacheWrite: 0 },
+  "composer-2": { input: 0.5, output: 2.5, cacheRead: 0.2, cacheWrite: 0 },
+  "composer-2.5": { input: 0.5, output: 2.5, cacheRead: 0.2, cacheWrite: 0 },
+  "composer-2.5-fast": { input: 3, output: 15, cacheRead: 0.5, cacheWrite: 0 },
+  "gemini-2.5-flash": { input: 0.3, output: 2.5, cacheRead: 0.03, cacheWrite: 0 },
+  "gemini-3-flash": { input: 0.5, output: 3, cacheRead: 0.05, cacheWrite: 0 },
+  "gemini-3-pro": { input: 2, output: 12, cacheRead: 0.2, cacheWrite: 0 },
+  "gemini-3.1-pro": { input: 2, output: 12, cacheRead: 0.2, cacheWrite: 0 },
+  "gpt-5": { input: 1.25, output: 10, cacheRead: 0.125, cacheWrite: 0 },
+  "gpt-5-mini": { input: 0.25, output: 2, cacheRead: 0.025, cacheWrite: 0 },
+  "gpt-5.2": { input: 1.75, output: 14, cacheRead: 0.175, cacheWrite: 0 },
+  "gpt-5.2-codex": { input: 1.75, output: 14, cacheRead: 0.175, cacheWrite: 0 },
+  "gpt-5.3-codex": { input: 1.75, output: 14, cacheRead: 0.175, cacheWrite: 0 },
+  "gpt-5.4": { input: 2.5, output: 15, cacheRead: 0.25, cacheWrite: 0 },
+  "gpt-5.4-mini": { input: 0.75, output: 4.5, cacheRead: 0.075, cacheWrite: 0 },
+  "gpt-5.5": { input: 2.5, output: 15, cacheRead: 0.25, cacheWrite: 0 },
+  "grok-4.20": { input: 2, output: 6, cacheRead: 0.2, cacheWrite: 0 },
+  // Mirrors pi core's built-in xai/grok-4.6 row (models.dev): 2 / 6 / 0.5 / 0.
+  // Cursor-side billing may differ; users can override via models.json.
+  "grok-4.6": { input: 2, output: 6, cacheRead: 0.5, cacheWrite: 0 },
+  "kimi-k2.5": { input: 0.6, output: 3, cacheRead: 0.1, cacheWrite: 0 },
+};
+
+export const DEFAULT_COST: ModelCost = { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 0 };
+
+export const MODEL_COST_PATTERNS: Array<{ match: (id: string) => boolean; cost: ModelCost }> = [
+  {
+    match: (id) => /fable-5\.1|fable-5-1(?!m)/i.test(id),
+    cost: MODEL_COST_TABLE["claude-fable-5-1"] ?? DEFAULT_COST,
+  },
+  {
+    match: (id) => /fable/i.test(id),
+    cost: MODEL_COST_TABLE["claude-fable-5"] ?? DEFAULT_COST,
+  },
+  {
+    match: (id) => /sonnet-5/i.test(id),
+    cost: MODEL_COST_TABLE["claude-sonnet-5"] ?? DEFAULT_COST,
+  },
+  {
+    match: (id) => /claude.*opus.*fast/i.test(id),
+    cost: { input: 30, output: 150, cacheRead: 3, cacheWrite: 37.5 },
+  },
+  {
+    match: (id) => /claude.*opus|opus-5|opus-4/i.test(id),
+    cost: MODEL_COST_TABLE["claude-4.6-opus"] ?? DEFAULT_COST,
+  },
+  {
+    match: (id) => /claude.*haiku/i.test(id),
+    cost: MODEL_COST_TABLE["claude-4.5-haiku"] ?? DEFAULT_COST,
+  },
+  {
+    match: (id) => /claude.*sonnet/i.test(id),
+    cost: MODEL_COST_TABLE["claude-4.6-sonnet"] ?? DEFAULT_COST,
+  },
+  {
+    match: (id) => /composer-2\.5.*fast|composer-2\.5-fast/i.test(id),
+    cost: MODEL_COST_TABLE["composer-2.5-fast"] ?? DEFAULT_COST,
+  },
+  {
+    match: (id) => /composer-2\.5/i.test(id),
+    cost: MODEL_COST_TABLE["composer-2.5"] ?? DEFAULT_COST,
+  },
+  { match: (id) => /composer/i.test(id), cost: MODEL_COST_TABLE["composer-1"] ?? DEFAULT_COST },
+  { match: (id) => /gpt-5\.5/i.test(id), cost: MODEL_COST_TABLE["gpt-5.5"] ?? DEFAULT_COST },
+  {
+    match: (id) => /gpt-5\.4.*mini/i.test(id),
+    cost: MODEL_COST_TABLE["gpt-5.4-mini"] ?? DEFAULT_COST,
+  },
+  { match: (id) => /gpt-5\.4/i.test(id), cost: MODEL_COST_TABLE["gpt-5.4"] ?? DEFAULT_COST },
+  { match: (id) => /gpt-5\.3/i.test(id), cost: MODEL_COST_TABLE["gpt-5.3-codex"] ?? DEFAULT_COST },
+  { match: (id) => /gpt-5\.2/i.test(id), cost: MODEL_COST_TABLE["gpt-5.2"] ?? DEFAULT_COST },
+  { match: (id) => /gpt-5.*mini/i.test(id), cost: MODEL_COST_TABLE["gpt-5-mini"] ?? DEFAULT_COST },
+  { match: (id) => /gpt-5/i.test(id), cost: MODEL_COST_TABLE["gpt-5"] ?? DEFAULT_COST },
+  {
+    match: (id) => /gemini.*3\.1/i.test(id),
+    cost: MODEL_COST_TABLE["gemini-3.1-pro"] ?? DEFAULT_COST,
+  },
+  {
+    match: (id) => /gemini.*flash/i.test(id),
+    cost: MODEL_COST_TABLE["gemini-2.5-flash"] ?? DEFAULT_COST,
+  },
+  { match: (id) => /gemini/i.test(id), cost: MODEL_COST_TABLE["gemini-3-pro"] ?? DEFAULT_COST },
+  {
+    match: (id) => /grok-4\.6/i.test(id),
+    cost: MODEL_COST_TABLE["grok-4.6"] ?? DEFAULT_COST,
+  },
+  { match: (id) => /grok/i.test(id), cost: MODEL_COST_TABLE["grok-4.20"] ?? DEFAULT_COST },
+  { match: (id) => /kimi/i.test(id), cost: MODEL_COST_TABLE["kimi-k2.5"] ?? DEFAULT_COST },
+];
+
+export function estimateModelCost(modelId: string): ModelCost {
+  const normalized = modelId.toLowerCase();
+  const exact = MODEL_COST_TABLE[normalized];
+  if (exact) return exact;
+  const stripped = normalized.replace(
+    /-(high|medium|low|preview|thinking|spark-preview|fast)$/g,
+    "",
+  );
+  const strippedMatch = MODEL_COST_TABLE[stripped];
+  if (strippedMatch) return strippedMatch;
+  return MODEL_COST_PATTERNS.find((p) => p.match(normalized))?.cost ?? DEFAULT_COST;
+}

package/src/models/index.ts

@@ -0,0 +1,6 @@
+/** Re-export catalog JSON for external tooling. Prefer provider registration via src/index.ts. */
+export { default as catalog } from "./catalog.json" with { type: "json" };
+export * from "./cost.js";
+export * from "./processing.js";
+export * from "./parameterized.js";
+export * from "./ask-catalog.js";

package/src/models/limits.ts

@@ -0,0 +1,36 @@
+/**
+ * Context-window and output-token ceilings for Cursor models.
+ *
+ * Cursor's `ModelDetails` carries neither number, so both are inferred from the
+ * model id and display name. Kept in a dependency-free module because the model
+ * catalog needs it at startup and must not drag the transport stack in with it.
+ */
+
+export const DEFAULT_CONTEXT_WINDOW = 200_000;
+export const DEFAULT_MAX_OUTPUT_TOKENS = 64_000;
+
+export function inferCursorContextWindow(id: string, name: string): number {
+  const text = `${id} ${name}`.toLowerCase();
+  if (/\b1\s*m\b|(?:^|-)1m(?:-|$)/.test(text)) return 1_000_000;
+  if (/\b272\s*k\b|(?:^|-)272k(?:-|$)/.test(text)) return 272_000;
+  return DEFAULT_CONTEXT_WINDOW;
+}
+
+/**
+ * Pi-side budgeting metadata only: the Cursor run request has no max-output
+ * field, so a wrong value here cannot fail a request upstream — it only
+ * mis-sizes Pi's output allowance.
+ *
+ * Conservative by design. Only families whose provider documents a ceiling above
+ * 64K are raised; everything else keeps the 64K floor Cursor's older models use.
+ */
+export function inferCursorMaxOutputTokens(id: string, name: string): number {
+  const text = `${id} ${name}`.toLowerCase();
+  // Claude 4.6 and newer (Opus/Sonnet) document a 128K output ceiling. Claude 4.5
+  // and earlier — Haiku 4.5 included — stay at 64K.
+  if (/claude-(?:[5-9]|4\.(?:[6-9]|\d{2,}))/.test(text)) return 128_000;
+  // Cursor labels these "Opus 4.6" / "Sonnet 4.6" rather than "claude-4.6-*".
+  if (/\b(?:sonnet|opus)\s*(?:[5-9]|4\.(?:[6-9]|\d{2,}))/.test(text)) return 128_000;
+  if (/\bgpt-5/.test(text)) return 128_000;
+  return DEFAULT_MAX_OUTPUT_TOKENS;
+}

package/src/models/parameterized.ts

@@ -0,0 +1,416 @@
+/**
+ * Parameterized Cursor models metadata conversion and catalog augmentation.
+ */
+
+import rawFallbackModels from "./catalog.json" with { type: "json" };
+import type {
+  CursorModelParameter,
+  CursorParameterizedModel,
+  CursorParameterizedVariant,
+} from "../client/cursor-wire.js";
+import type { CursorModel } from "../stream/model-discovery.js";
+import { inferCursorContextWindow, inferCursorMaxOutputTokens } from "./limits.js";
+import { supportsReasoningModelId } from "./processing.js";
+
+export const GPT55_VARIANTS = [
+  {
+    idPart: "",
+    label: "272K",
+    context: "272k",
+    contextWindow: 272_000,
+    requestedMaxMode: false,
+    fastOptions: [false, true],
+  },
+  {
+    idPart: "-max",
+    label: "272K Max",
+    context: "272k",
+    contextWindow: 272_000,
+    requestedMaxMode: true,
+    fastOptions: [false, true],
+  },
+  {
+    idPart: "-1m",
+    label: "1M",
+    context: "1m",
+    contextWindow: 1_000_000,
+    requestedMaxMode: true,
+    fastOptions: [false],
+  },
+] as const;
+
+export const GPT55_REASONING_LEVELS = [
+  { suffix: "none", label: "None", value: "none" },
+  { suffix: "low", label: "Low", value: "low" },
+  { suffix: "medium", label: "", value: "medium" },
+  { suffix: "high", label: "High", value: "high" },
+  { suffix: "extra-high", label: "Extra High", value: "extra-high" },
+] as const;
+
+export function gpt55ParameterizedModels(): CursorModel[] {
+  const models: CursorModel[] = [];
+  for (const variant of GPT55_VARIANTS) {
+    // Cursor treats maxMode as an orthogonal request flag. The model picker
+    // cannot toggle Cursor-specific flags, so expose useful maxMode states as
+    // explicit rows. Cursor's metadata does not include context=1m + fast=true,
+    // so the 1M variant intentionally has fast=false only.
+    for (const fast of variant.fastOptions) {
+      for (const reasoning of GPT55_REASONING_LEVELS) {
+        const id = `gpt-5.5${variant.idPart}-${reasoning.suffix}${fast ? "-fast" : ""}`;
+        const nameParts = ["GPT-5.5", variant.label, reasoning.label, fast ? "Fast" : ""].filter(
+          Boolean,
+        );
+        models.push({
+          id,
+          name: nameParts.join(" "),
+          reasoning: true,
+          contextWindow: variant.contextWindow,
+          maxTokens: inferCursorMaxOutputTokens(id, nameParts.join(" ")),
+          requestedModelId: "gpt-5.5",
+          requiresMaxMode: variant.context === "1m",
+          requestedMaxMode: variant.requestedMaxMode,
+          parameters: [
+            { id: "context", value: variant.context },
+            { id: "reasoning", value: reasoning.value },
+            { id: "fast", value: String(fast) },
+          ],
+        });
+      }
+    }
+  }
+  return models;
+}
+
+export function parameterValue(parameters: CursorModelParameter[], id: string): string | undefined {
+  return parameters.find((parameter) => parameter.id === id)?.value;
+}
+
+export function contextWindowFromParameter(
+  context: string | undefined,
+  fallback = 200_000,
+): number {
+  if (context === "272k") return 272_000;
+  if (context === "1m") return 1_000_000;
+  const k = context?.match(/^(\d+)k$/i)?.[1];
+  if (k) return Number(k) * 1_000;
+  const m = context?.match(/^(\d+)m$/i)?.[1];
+  if (m) return Number(m) * 1_000_000;
+  return fallback;
+}
+
+export function cursorEffortSuffix(value: string): string {
+  return value;
+}
+
+export function cursorEffortLabel(value: string): string {
+  return (
+    GPT55_REASONING_LEVELS.find((level) => level.value === value)?.label ||
+    ({ xhigh: "Extra High", max: "Max", none: "None" } as Record<string, string>)[value] ||
+    value.replace(/-/g, " ").replace(/\b\w/g, (char) => char.toUpperCase())
+  );
+}
+
+export function metadataEffortParameterId(
+  variant: CursorParameterizedVariant,
+): "reasoning" | "effort" | undefined {
+  if (variant.parameters.some((parameter) => parameter.id === "reasoning")) return "reasoning";
+  if (variant.parameters.some((parameter) => parameter.id === "effort")) return "effort";
+  return undefined;
+}
+
+export function isDefaultContext(context: string | undefined): boolean {
+  if (!context) return true;
+  return context === "200k" || context === "272k" || context === "300k";
+}
+
+export function contextIdPart(context: string | undefined): string {
+  return context && !isDefaultContext(context) ? `-${context.toLowerCase()}` : "";
+}
+
+export function contextLabel(context: string | undefined): string | undefined {
+  if (!context || isDefaultContext(context)) return undefined;
+  return context.toUpperCase();
+}
+
+export function maxModeIdPart(
+  modelName: string,
+  context: string | undefined,
+  requestedMaxMode: boolean,
+  hasEffortParameter: boolean,
+): string {
+  // 1M context already names the Max/extended-context selection. For default
+  // context windows, expose maxMode as an explicit row suffix. If the Cursor
+  // model ID already contains "max" (for example gpt-5.1-codex-max), or if
+  // this row has no effort parameter, use a clearer suffix so the model parser
+  // does not confuse Max Mode with a Cursor effort value.
+  if (!requestedMaxMode || context === "1m") return "";
+  return !hasEffortParameter || /(^|-)max($|-)/i.test(modelName) ? "-max-mode" : "-max";
+}
+
+export function maxModeLabel(
+  modelName: string,
+  context: string | undefined,
+  requestedMaxMode: boolean,
+  hasEffortParameter: boolean,
+): string | undefined {
+  const idPart = maxModeIdPart(modelName, context, requestedMaxMode, hasEffortParameter);
+  if (!idPart) return undefined;
+  return idPart === "-max-mode" ? "Max Mode" : "Max";
+}
+
+export function parameterizedBaseId(
+  modelName: string,
+  variant: CursorParameterizedVariant,
+  requestedMaxMode: boolean,
+  hasEffortParameter: boolean,
+): string {
+  const context = parameterValue(variant.parameters, "context");
+  return `${modelName}${contextIdPart(context)}${maxModeIdPart(modelName, context, requestedMaxMode, hasEffortParameter)}`;
+}
+
+export function parameterizedBaseLabel(
+  model: CursorParameterizedModel,
+  variant: CursorParameterizedVariant,
+  requestedMaxMode: boolean,
+  hasEffortParameter: boolean,
+): string[] {
+  const context = parameterValue(variant.parameters, "context");
+  return [
+    model.clientDisplayName || model.name,
+    contextLabel(context),
+    maxModeLabel(model.name, context, requestedMaxMode, hasEffortParameter),
+  ].filter(Boolean) as string[];
+}
+
+// Every variant of a model is checked against every variant of that same model, so normalizing
+// the model's variant sets on each call made catalog building O(variants^2) in string sorts —
+// the dominant cost of activation with a live catalog. The advertised sets are fixed for a given
+// model object, so derive them once and keep them keyed by model identity.
+const variantParameterSetCache = new WeakMap<CursorParameterizedModel, Set<string>>();
+
+function advertisedParameterSets(model: CursorParameterizedModel): Set<string> {
+  let sets = variantParameterSetCache.get(model);
+  if (!sets) {
+    sets = new Set(model.variants.map((variant) => normalizeParameterValues(variant.parameters)));
+    variantParameterSetCache.set(model, sets);
+  }
+  return sets;
+}
+
+export function hasVariantParameterSet(
+  model: CursorParameterizedModel,
+  parameters: CursorModelParameter[],
+): boolean {
+  return advertisedParameterSets(model).has(normalizeParameterValues(parameters));
+}
+
+// Codepoint order rather than `localeCompare`: this string is only ever compared against other
+// outputs of this function, so the order just has to be deterministic and total. `localeCompare`
+// is both far slower and can rank distinct strings as equal, which would leave the key dependent
+// on the input array's order.
+function compareCodepoint(a: string, b: string): number {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+export function normalizeParameterValues(parameters: CursorModelParameter[]): string {
+  return parameters
+    .map((parameter) => `${parameter.id}=${parameter.value}`)
+    .sort(compareCodepoint)
+    .join(";");
+}
+
+export function buildParameterizedRowsFromGroup(options: {
+  model: CursorParameterizedModel;
+  variants: CursorParameterizedVariant[];
+  requestedMaxMode: boolean;
+  effortParameterId?: "reasoning" | "effort";
+}): CursorModel[] {
+  const first = options.variants[0];
+  if (!first) return [];
+  if (options.requestedMaxMode && !first.isMaxMode && !options.model.supportsMaxMode) return [];
+
+  const context = parameterValue(first.parameters, "context");
+  const fast = parameterValue(first.parameters, "fast") === "true";
+  const thinking = parameterValue(first.parameters, "thinking") === "true";
+  const hasEffortParameter = Boolean(options.effortParameterId);
+  const baseId = parameterizedBaseId(
+    options.model.name,
+    first,
+    options.requestedMaxMode,
+    hasEffortParameter,
+  );
+  const baseLabelParts = parameterizedBaseLabel(
+    options.model,
+    first,
+    options.requestedMaxMode,
+    hasEffortParameter,
+  );
+  const contextWindow = contextWindowFromParameter(
+    context,
+    options.requestedMaxMode
+      ? (options.model.contextTokenLimitForMaxMode ?? options.model.contextTokenLimit ?? 200_000)
+      : (options.model.contextTokenLimit ?? 200_000),
+  );
+
+  return options.variants.flatMap((variant) => {
+    const parameters = variant.parameters.map((parameter) => ({
+      id: parameter.id,
+      value: parameter.value,
+    }));
+    if (!hasVariantParameterSet(options.model, parameters)) return [];
+
+    const effort = options.effortParameterId
+      ? parameterValue(variant.parameters, options.effortParameterId)
+      : undefined;
+    const id = options.effortParameterId
+      ? `${baseId}-${cursorEffortSuffix(effort ?? "")}${thinking ? "-thinking" : ""}${fast ? "-fast" : ""}`
+      : `${baseId}${thinking ? "-thinking" : ""}${fast ? "-fast" : ""}`;
+    const name = [
+      ...baseLabelParts,
+      effort ? cursorEffortLabel(effort) : undefined,
+      thinking ? "Thinking" : undefined,
+      fast ? "Fast" : undefined,
+    ]
+      .filter(Boolean)
+      .join(" ");
+
+    return [
+      {
+        id,
+        name,
+        reasoning: Boolean(options.effortParameterId) || thinking,
+        contextWindow,
+        maxTokens: inferCursorMaxOutputTokens(id, name),
+        requestedModelId: options.model.name,
+        requiresMaxMode: variant.isMaxMode,
+        requestedMaxMode: options.requestedMaxMode,
+        supportsImages: options.model.supportsImages,
+        parameters,
+      } satisfies CursorModel,
+    ];
+  });
+}
+
+export function parameterGroupKey(
+  variant: CursorParameterizedVariant,
+  effortParameterId?: string,
+): string {
+  const params = variant.parameters
+    .filter((parameter) => parameter.id !== effortParameterId)
+    .map((parameter) => `${parameter.id}=${parameter.value}`)
+    .sort(compareCodepoint)
+    .join(";");
+  return `${variant.isMaxMode ? "max" : "nonmax"}|${params}`;
+}
+
+export function shouldGenerateSyntheticMaxRows(
+  model: CursorParameterizedModel,
+  variant: CursorParameterizedVariant,
+): boolean {
+  // Cursor's metadata has both per-variant isMaxMode and model-level
+  // supportsMaxMode. Some supported Max Mode combinations are represented only
+  // by supportsMaxMode=true over a non-Max parameter set, so expose explicit
+  // max-mode rows for every such advertised parameter set.
+  return model.supportsMaxMode === true && !variant.isMaxMode;
+}
+
+export function modelsFromParameterizedMetadata(
+  parameterizedModels: CursorParameterizedModel[],
+): CursorModel[] {
+  const rows: CursorModel[] = [];
+  for (const model of parameterizedModels) {
+    const groups = new Map<
+      string,
+      { effortParameterId?: "reasoning" | "effort"; variants: CursorParameterizedVariant[] }
+    >();
+    for (const variant of model.variants) {
+      if (variant.parameters.length === 0) continue;
+      const effortParameterId = metadataEffortParameterId(variant);
+      const key = parameterGroupKey(variant, effortParameterId);
+      const group = groups.get(key) ?? { effortParameterId, variants: [] };
+      group.variants.push(variant);
+      groups.set(key, group);
+    }
+
+    for (const group of groups.values()) {
+      const first = group.variants[0];
+      if (!first) continue;
+      rows.push(
+        ...buildParameterizedRowsFromGroup({
+          model,
+          variants: group.variants,
+          requestedMaxMode: first.isMaxMode,
+          effortParameterId: group.effortParameterId,
+        }),
+      );
+      if (shouldGenerateSyntheticMaxRows(model, first)) {
+        rows.push(
+          ...buildParameterizedRowsFromGroup({
+            model,
+            variants: group.variants,
+            requestedMaxMode: true,
+            effortParameterId: group.effortParameterId,
+          }),
+        );
+      }
+    }
+  }
+  return rows;
+}
+
+export function normalizeDisplayModel(model: CursorModel): CursorModel {
+  if (model.id !== "default") return model;
+  return {
+    ...model,
+    id: "auto",
+    name: model.name && model.name !== "default" ? model.name : "Auto",
+    requestedModelId: model.requestedModelId ?? "default",
+  };
+}
+
+export function augmentCursorModels(
+  raw: CursorModel[],
+  parameterizedModels: CursorParameterizedModel[] = [],
+): CursorModel[] {
+  const byId = new Map<string, CursorModel>();
+  const imageSupportByModelId = new Map(
+    parameterizedModels
+      .filter((model) => typeof model.supportsImages === "boolean")
+      .map((model) => [model.name, model.supportsImages!]),
+  );
+  for (const model of raw.map(normalizeDisplayModel)) {
+    const lookupId = model.requestedModelId ?? model.id;
+    const metadataSupportsImages = imageSupportByModelId.get(lookupId);
+    byId.set(model.id, {
+      ...model,
+      ...(model.supportsImages === undefined && metadataSupportsImages !== undefined
+        ? { supportsImages: metadataSupportsImages }
+        : {}),
+    });
+  }
+
+  const metadataRows =
+    modelsFromParameterizedMetadata(parameterizedModels).map(normalizeDisplayModel);
+  for (const model of metadataRows) byId.set(model.id, model);
+
+  // Fallback for static/offline discovery. Cursor exposes GPT-5.5 context as
+  // parameters (272K vs 1M), not distinct backend model IDs.
+  if (metadataRows.length === 0 && raw.some((model) => /^gpt-5\.5(?:-|$)/.test(model.id))) {
+    for (const model of gpt55ParameterizedModels()) byId.set(model.id, model);
+  }
+
+  return [...byId.values()];
+}
+
+// The bundled catalog is a snapshot of a live discovery response, so its derived
+// columns are recomputed here rather than trusted. Ten rows had already drifted:
+// every "1M" Claude row claimed a 200K window because the file was hand-edited
+// after `inferCursorContextWindow` learned to read the "1M" suffix.
+export const FALLBACK_MODELS: CursorModel[] = augmentCursorModels(
+  rawFallbackModels as CursorModel[],
+).map((model) => ({
+  ...model,
+  reasoning: supportsReasoningModelId(model.id),
+  contextWindow: inferCursorContextWindow(model.id, model.name),
+  maxTokens: inferCursorMaxOutputTokens(model.id, model.name),
+}));