@rama_nigg/open-cursor 2.3.19 → 2.4.0

package/src/mcp/config.ts

@@ -93,6 +93,55 @@ export function readMcpConfigs(deps: ReadMcpConfigsDeps = {}): McpServerConfig[]
   return configs;
 }
 
+interface ReadSubagentNamesDeps {
+  configJson?: string;
+  existsSync?: (path: string) => boolean;
+  readFileSync?: (path: string, enc: BufferEncoding) => string;
+  env?: NodeJS.ProcessEnv;
+}
+
+export function readSubagentNames(deps: ReadSubagentNamesDeps = {}): string[] {
+  let raw: string;
+
+  if (deps.configJson != null) {
+    raw = deps.configJson;
+  } else {
+    const exists = deps.existsSync ?? nodeExistsSync;
+    const readFile = deps.readFileSync ?? nodeReadFileSync;
+    const configPath = resolveOpenCodeConfigPath(deps.env ?? process.env);
+    if (!exists(configPath)) return ["general-purpose"];
+    try {
+      raw = readFile(configPath, "utf8");
+    } catch {
+      return ["general-purpose"];
+    }
+  }
+
+  let parsed: Record<string, unknown>;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return ["general-purpose"];
+  }
+
+  const agentSection = parsed.agent;
+  if (!agentSection || typeof agentSection !== "object" || Array.isArray(agentSection)) {
+    return ["general-purpose"];
+  }
+
+  const agents = agentSection as Record<string, unknown>;
+  const names = Object.keys(agents);
+  if (names.length === 0) return ["general-purpose"];
+
+  const subagentNames = names.filter((name) => {
+    const entry = agents[name];
+    return entry && typeof entry === "object" && !Array.isArray(entry)
+      && (entry as Record<string, unknown>).mode === "subagent";
+  });
+
+  return subagentNames.length > 0 ? subagentNames : names;
+}
+
 function isStringRecord(v: unknown): v is Record<string, string> {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }

package/src/mcp/tool-bridge.ts

@@ -109,7 +109,7 @@ function mcpSchemaToZod(inputSchema: Record<string, unknown> | undefined, z: any
         zodType = z.array(z.any());
         break;
       case "object":
-        zodType = z.record(z.any());
+        zodType = z.record(z.string(), z.any());
         break;
       default:
         zodType = z.any();

package/src/models/discovery.ts

@@ -1,4 +1,5 @@
 import type { ModelInfo, DiscoveryConfig } from "./types.js";
+import { resolveCursorAgentBinary } from "../utils/binary.js";
 
 interface CacheEntry {
   models: ModelInfo[];
@@ -51,7 +52,7 @@ export class ModelDiscoveryService {
   private async queryViaCLI(): Promise<ModelInfo[]> {
     try {
       const bunAny = (globalThis as any).Bun;
-      const proc = bunAny.spawn(["cursor-agent", "models", "--json"], {
+      const proc = bunAny.spawn([resolveCursorAgentBinary(), "models", "--json"], {
         timeout: 5000,
         stdout: "pipe",
         stderr: "pipe"
@@ -78,7 +79,7 @@ export class ModelDiscoveryService {
   private async queryViaHelp(): Promise<ModelInfo[]> {
     try {
       const bunAny = (globalThis as any).Bun;
-      const proc = bunAny.spawn(["cursor-agent", "--help"], {
+      const proc = bunAny.spawn([resolveCursorAgentBinary(), "--help"], {
         timeout: 5000,
         stdout: "pipe",
         stderr: "pipe"

package/src/models/pricing.ts

@@ -0,0 +1,196 @@
+export type OpenCodeModelCost = {
+  input: number;
+  output: number;
+  cache_read?: number;
+  cache_write?: number;
+  context_over_200k?: OpenCodeModelCost;
+};
+
+export type CursorPricingCoverage = {
+  priced: string[];
+  missing: string[];
+};
+
+export type OpenCodeModelCostValidation = {
+  valid: boolean;
+  errors: string[];
+};
+
+export const CURSOR_PRICING_DOC_URL = "https://cursor.com/docs/models-and-pricing";
+
+export const CURSOR_PRICING_DOC_MARKERS = [
+  "Auto",
+  "Composer 2",
+  "Composer 1.5",
+  "Claude 4.6",
+  "Claude 4.6 Sonnet",
+  "Claude Opus 4.7",
+  "Gemini 3.1 Pro",
+  "Gemini 3 Flash",
+  "GPT-5.3 Codex",
+  "GPT-5.4",
+  "GPT-5.5",
+  "Grok 4.20",
+  "Kimi K2.5",
+];
+
+// Official Cursor prices per 1M tokens from https://cursor.com/docs/models-and-pricing.
+const AUTO_COST = cost(1.25, 6, 0.25, 1.25);
+const COMPOSER_2_COST = cost(0.5, 2.5, 0.2, 0.5);
+const COMPOSER_2_FAST_COST = cost(1.5, 7.5, 0.35, 1.5);
+const COMPOSER_1_5_COST = cost(3.5, 17.5, 0.35, 3.5);
+
+const CLAUDE_SONNET_COST = cost(3, 15, 0.3, 3.75);
+const CLAUDE_SONNET_LONG_CONTEXT_COST = cost(6, 22.5, 0.6, 7.5);
+const CLAUDE_SONNET_WITH_LONG_CONTEXT_COST = withLongContext(
+  CLAUDE_SONNET_COST,
+  CLAUDE_SONNET_LONG_CONTEXT_COST,
+);
+const CLAUDE_OPUS_COST = cost(5, 25, 0.5, 6.25);
+const CLAUDE_OPUS_FAST_COST = cost(30, 150, 3, 37.5);
+
+const GEMINI_3_PRO_COST = withLongContext(cost(2, 12, 0.2, 2), cost(4, 18, 0.4, 4));
+const GEMINI_3_FLASH_COST = cost(0.5, 3, 0.05, 0.5);
+
+const GPT_5_1_COST = cost(1.25, 10, 0.125, 1.25);
+const GPT_5_2_COST = cost(1.75, 14, 0.175, 1.75);
+const GPT_5_3_CODEX_COST = cost(1.75, 14, 0.175, 1.75);
+const GPT_5_4_COST = withLongContext(cost(2.5, 15, 0.25, 2.5), cost(5, 22.5, 0.5, 5));
+const GPT_5_4_FAST_COST = cost(5, 30, 0.5, 5);
+const GPT_5_4_MINI_COST = cost(0.75, 4.5, 0.075, 0.75);
+const GPT_5_4_NANO_COST = cost(0.2, 1.25, 0.02, 0.2);
+const GPT_5_5_COST = withLongContext(cost(5, 30, 0.5, 5), cost(10, 45, 1, 10));
+const GPT_5_MINI_COST = cost(0.25, 2, 0.025, 0.25);
+
+const GROK_4_20_COST = withLongContext(cost(2, 6, 0.2, 2), cost(4, 12, 0.4, 4));
+const KIMI_K2_5_COST = cost(0.6, 3, 0.1, 0.6);
+
+export function getCursorModelCost(modelId: string): OpenCodeModelCost | undefined {
+  if (modelId === "auto") return AUTO_COST;
+  if (modelId === "composer-2-fast") return COMPOSER_2_FAST_COST;
+  if (modelId === "composer-2") return COMPOSER_2_COST;
+  if (modelId === "composer-1.5") return COMPOSER_1_5_COST;
+
+  if (modelId.startsWith("claude-opus-4-7")) return CLAUDE_OPUS_COST;
+  if (modelId.startsWith("claude-4.6-opus")) {
+    return modelId.endsWith("-fast") ? CLAUDE_OPUS_FAST_COST : CLAUDE_OPUS_COST;
+  }
+  if (modelId.startsWith("claude-4.5-opus")) return CLAUDE_OPUS_COST;
+  if (modelId.startsWith("claude-4.6-sonnet")) return CLAUDE_SONNET_WITH_LONG_CONTEXT_COST;
+  if (modelId.startsWith("claude-4.5-sonnet")) return CLAUDE_SONNET_WITH_LONG_CONTEXT_COST;
+  if (modelId.startsWith("claude-4-sonnet")) return CLAUDE_SONNET_COST;
+
+  if (modelId === "gemini-3.1-pro") return GEMINI_3_PRO_COST;
+  if (modelId === "gemini-3-flash") return GEMINI_3_FLASH_COST;
+
+  if (modelId.startsWith("gpt-5.5")) return GPT_5_5_COST;
+  if (modelId.startsWith("gpt-5.4-mini")) return GPT_5_4_MINI_COST;
+  if (modelId.startsWith("gpt-5.4-nano")) return GPT_5_4_NANO_COST;
+  if (modelId.startsWith("gpt-5.4")) {
+    return modelId.endsWith("-fast") ? GPT_5_4_FAST_COST : GPT_5_4_COST;
+  }
+  if (modelId.startsWith("gpt-5.3-codex")) return GPT_5_3_CODEX_COST;
+  if (modelId.startsWith("gpt-5.2-codex")) return GPT_5_2_COST;
+  if (modelId.startsWith("gpt-5.2")) return GPT_5_2_COST;
+  if (modelId.startsWith("gpt-5.1-codex-mini")) return GPT_5_MINI_COST;
+  if (modelId.startsWith("gpt-5.1-codex-max")) return GPT_5_1_COST;
+  if (modelId.startsWith("gpt-5.1")) return GPT_5_1_COST;
+  if (modelId === "gpt-5-mini") return GPT_5_MINI_COST;
+
+  if (modelId.startsWith("grok-4-20")) return GROK_4_20_COST;
+  if (modelId === "kimi-k2.5") return KIMI_K2_5_COST;
+
+  return undefined;
+}
+
+export function applyCursorModelCost<T extends Record<string, unknown>>(
+  modelId: string,
+  entry: T,
+): T & { cost?: OpenCodeModelCost } {
+  const modelCost = getCursorModelCost(modelId);
+  if (!modelCost) return entry;
+  return { ...entry, cost: modelCost };
+}
+
+export function checkCursorPricingCoverage(modelIds: string[]): CursorPricingCoverage {
+  const priced: string[] = [];
+  const missing: string[] = [];
+
+  for (const modelId of modelIds) {
+    if (getCursorModelCost(modelId)) {
+      priced.push(modelId);
+    } else {
+      missing.push(modelId);
+    }
+  }
+
+  return { priced, missing };
+}
+
+export function validateOpenCodeModelCost(
+  value: unknown,
+  path = "cost",
+): OpenCodeModelCostValidation {
+  const errors: string[] = [];
+  collectCostValidationErrors(value, path, errors);
+  return { valid: errors.length === 0, errors };
+}
+
+export function isOpenCodeModelCost(value: unknown): value is OpenCodeModelCost {
+  return validateOpenCodeModelCost(value).valid;
+}
+
+function cost(input: number, output: number, cacheRead: number, cacheWrite: number): OpenCodeModelCost {
+  return {
+    input,
+    output,
+    cache_read: cacheRead,
+    cache_write: cacheWrite,
+  };
+}
+
+function withLongContext(
+  base: OpenCodeModelCost,
+  longContext: OpenCodeModelCost,
+): OpenCodeModelCost {
+  return {
+    ...base,
+    context_over_200k: longContext,
+  };
+}
+
+function collectCostValidationErrors(value: unknown, path: string, errors: string[]): void {
+  if (!isRecord(value)) {
+    errors.push(`${path} must be an object`);
+    return;
+  }
+
+  validateRequiredPrice(value.input, `${path}.input`, errors);
+  validateRequiredPrice(value.output, `${path}.output`, errors);
+  validateOptionalPrice(value.cache_read, `${path}.cache_read`, errors);
+  validateOptionalPrice(value.cache_write, `${path}.cache_write`, errors);
+
+  if (value.context_over_200k !== undefined) {
+    collectCostValidationErrors(value.context_over_200k, `${path}.context_over_200k`, errors);
+  }
+}
+
+function validateRequiredPrice(value: unknown, path: string, errors: string[]): void {
+  if (!isNonNegativeFiniteNumber(value)) {
+    errors.push(`${path} must be a non-negative finite number`);
+  }
+}
+
+function validateOptionalPrice(value: unknown, path: string, errors: string[]): void {
+  if (value !== undefined && !isNonNegativeFiniteNumber(value)) {
+    errors.push(`${path} must be a non-negative finite number`);
+  }
+}
+
+function isNonNegativeFiniteNumber(value: unknown): value is number {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}