@evanovation/open-cursor 2.4.15

package/src/mcp/tool-bridge.ts

@@ -0,0 +1,133 @@
+import { tool } from "@opencode-ai/plugin/tool";
+import { createLogger } from "../utils/logger.js";
+import type { McpClientManager } from "./client-manager.js";
+
+const log = createLogger("mcp:tool-bridge");
+
+export const MCP_TOOL_PREFIX = "mcp__";
+
+interface DiscoveredMcpTool {
+  name: string;
+  serverName: string;
+  description?: string;
+  inputSchema?: Record<string, unknown>;
+}
+
+/**
+ * Build plugin `tool()` hook entries for discovered MCP tools.
+ *
+ * Each MCP tool is namespaced as `mcp__<server_name>__<tool_name>`
+ * to avoid collision with local tools and to make the source clear.
+ */
+export function buildMcpToolHookEntries(
+  tools: DiscoveredMcpTool[],
+  manager: McpClientManager,
+): Record<string, any> {
+  const z = tool.schema;
+  const entries: Record<string, any> = {};
+
+  for (const t of tools) {
+    const hookName = namespaceMcpTool(t.serverName, t.name);
+
+    if (entries[hookName]) {
+      log.debug("Duplicate MCP tool name, skipping", { hookName });
+      continue;
+    }
+
+    const zodArgs = mcpSchemaToZod(t.inputSchema, z);
+    const serverName = t.serverName;
+    const toolName = t.name;
+
+    entries[hookName] = tool({
+      description: t.description || `MCP tool: ${t.name} (server: ${t.serverName})`,
+      args: zodArgs,
+      async execute(args: any) {
+        log.debug("Executing MCP tool", { server: serverName, tool: toolName });
+        const result = await manager.callTool(serverName, toolName, args ?? {});
+        if (result.startsWith("Error:")) {
+          throw new Error(result);
+        }
+        return result;
+      },
+    });
+  }
+
+  log.debug("Built MCP tool hook entries", { count: Object.keys(entries).length });
+  return entries;
+}
+
+/**
+ * Build OpenAI-format tool definitions for discovered MCP tools.
+ * These are injected into chat.params so the model sees the tools.
+ */
+export function buildMcpToolDefinitions(tools: DiscoveredMcpTool[]): any[] {
+  const defs: any[] = [];
+
+  for (const t of tools) {
+    const name = namespaceMcpTool(t.serverName, t.name);
+    defs.push({
+      type: "function",
+      function: {
+        name,
+        description: t.description || `MCP tool: ${t.name} (server: ${t.serverName})`,
+        parameters: t.inputSchema ?? { type: "object", properties: {} },
+      },
+    });
+  }
+
+  return defs;
+}
+
+export function namespaceMcpTool(serverName: string, toolName: string): string {
+  const sanitizedServer = serverName.replace(/[^a-zA-Z0-9]/g, "_");
+  const sanitizedTool = toolName.replace(/[^a-zA-Z0-9]/g, "_");
+  return `${MCP_TOOL_PREFIX}${sanitizedServer}__${sanitizedTool}`;
+}
+
+function mcpSchemaToZod(inputSchema: Record<string, unknown> | undefined, z: any): any {
+  if (!inputSchema || typeof inputSchema !== "object") {
+    return {};
+  }
+
+  const properties = (inputSchema.properties ?? {}) as Record<string, any>;
+  const required = (inputSchema.required ?? []) as string[];
+  const shape: any = {};
+
+  for (const [key, prop] of Object.entries(properties)) {
+    let zodType: any;
+
+    switch (prop?.type) {
+      case "string":
+        zodType = z.string();
+        break;
+      case "number":
+      case "integer":
+        zodType = z.number();
+        break;
+      case "boolean":
+        zodType = z.boolean();
+        break;
+      case "array":
+        zodType = z.array(z.any());
+        break;
+      case "object":
+        zodType = z.record(z.string(), z.any());
+        break;
+      default:
+        zodType = z.any();
+        break;
+    }
+
+    if (prop?.description) {
+      zodType = zodType.describe(prop.description);
+    }
+
+    if (!required.includes(key)) {
+      zodType = zodType.optional();
+    }
+
+    shape[key] = zodType;
+  }
+
+  return shape;
+}

package/src/models/config.ts

@@ -0,0 +1,64 @@
+import type { ModelInfo } from "./types.js";
+
+interface OpenCodeModelConfig {
+  name: string;
+  tools?: boolean;
+  reasoning?: boolean;
+  description?: string;
+  [key: string]: any;
+}
+
+interface OpenCodeProviderConfig {
+  npm?: string;
+  name?: string;
+  options?: Record<string, any>;
+  models: Record<string, OpenCodeModelConfig>;
+}
+
+export class ConfigUpdater {
+  formatModels(models: ModelInfo[]): Record<string, OpenCodeModelConfig> {
+    const formatted: Record<string, OpenCodeModelConfig> = {};
+
+    for (const model of models) {
+      // Normalize ID for JSON key (replace dots/dashes)
+      const key = model.id.replace(/[.-]/g, "");
+
+      formatted[key] = {
+        name: model.name,
+        tools: true,
+        reasoning: true,
+        description: model.description
+      };
+    }
+
+    return formatted;
+  }
+
+  mergeModels(
+    existing: Record<string, OpenCodeModelConfig>,
+    discovered: ModelInfo[]
+  ): Record<string, OpenCodeModelConfig> {
+    const formatted = this.formatModels(discovered);
+
+    // Merge, preserving existing custom fields
+    return {
+      ...formatted,
+      ...existing // Existing takes precedence for conflicts
+    };
+  }
+
+  generateProviderConfig(
+    models: ModelInfo[],
+    baseURL: string
+  ): OpenCodeProviderConfig {
+    return {
+      npm: "@ai-sdk/openai-compatible",
+      name: "Cursor Agent Provider",
+      options: {
+        baseURL,
+        apiKey: "cursor-agent"
+      },
+      models: this.formatModels(models)
+    };
+  }
+}

package/src/models/discovery.ts

@@ -0,0 +1,105 @@
+import type { ModelInfo, DiscoveryConfig } from "./types.js";
+import { listModelsViaRunner } from "../client/sdk-child.js";
+import { discoverModelsFromCursorAgent } from "../cli/model-discovery.js";
+import { resolveSdkApiKey } from "../auth.js";
+import { parseCursorBackendPreference } from "../provider/backend.js";
+
+interface CacheEntry {
+  models: ModelInfo[];
+  timestamp: number;
+}
+
+export class ModelDiscoveryService {
+  private cache: CacheEntry | null = null;
+  private cacheTTL: number;
+  private fallbackModels: ModelInfo[];
+
+  constructor(config: DiscoveryConfig = {}) {
+    this.cacheTTL = config.cacheTTL || 5 * 60 * 1000; // 5 minutes
+    this.fallbackModels = config.fallbackModels || this.getDefaultModels();
+  }
+
+  async discover(apiKey?: string): Promise<ModelInfo[]> {
+    // Check cache
+    if (this.cache && Date.now() - this.cache.timestamp < this.cacheTTL) {
+      return this.cache.models;
+    }
+
+    const backendPreference = parseCursorBackendPreference(process.env.CURSOR_ACP_BACKEND).preference;
+    const queryOrder = backendPreference === "sdk"
+      ? ["sdk"]
+      : backendPreference === "cursor-agent"
+        ? ["cursor-agent"]
+        : ["cursor-agent", "sdk"];
+
+    for (const backend of queryOrder) {
+      try {
+        const models = backend === "cursor-agent"
+          ? await this.queryCursorAgent()
+          : await this.queryViaSdk(apiKey);
+        this.cache = { models, timestamp: Date.now() };
+        return models;
+      } catch {
+        // Try the next backend before falling back to static defaults.
+      }
+    }
+
+    this.cache = { models: this.fallbackModels, timestamp: Date.now() };
+    return this.fallbackModels;
+  }
+
+  async queryCursorAgent(apiKey?: string): Promise<ModelInfo[]> {
+    void apiKey;
+    return discoverModelsFromCursorAgent().map((model) => ({
+      id: model.id,
+      name: model.name,
+      description: `Cursor ${model.name} model`,
+    }));
+  }
+
+  private async queryViaSdk(apiKey?: string): Promise<ModelInfo[]> {
+    // Use the SDK runner to list models
+    const key = resolveSdkApiKey({ env: process.env, storedApiKey: apiKey });
+    if (!key) {
+      throw new Error("No Cursor API key available");
+    }
+
+    const sdkModels = await listModelsViaRunner(key);
+    
+    // Map SDK model format to ModelInfo
+    return sdkModels.map((m) => ({
+      id: m.id,
+      name: m.name,
+      description: `Cursor ${m.name} model`,
+    }));
+  }
+
+  private getDefaultModels(): ModelInfo[] {
+    return [
+      { id: "auto", name: "Auto", description: "Auto-select best model" },
+      { id: "composer-1.5", name: "Composer 1.5" },
+      { id: "composer-1", name: "Composer 1" },
+      { id: "opus-4.6-thinking", name: "Claude 4.6 Opus (Thinking)" },
+      { id: "opus-4.6", name: "Claude 4.6 Opus" },
+      { id: "sonnet-4.6", name: "Claude 4.6 Sonnet" },
+      { id: "sonnet-4.6-thinking", name: "Claude 4.6 Sonnet (Thinking)" },
+      { id: "opus-4.5", name: "Claude 4.5 Opus" },
+      { id: "opus-4.5-thinking", name: "Claude 4.5 Opus (Thinking)" },
+      { id: "sonnet-4.5", name: "Claude 4.5 Sonnet" },
+      { id: "sonnet-4.5-thinking", name: "Claude 4.5 Sonnet (Thinking)" },
+      { id: "gpt-5.4-high", name: "GPT-5.4 High" },
+      { id: "gpt-5.4-medium", name: "GPT-5.4" },
+      { id: "gpt-5.3-codex", name: "GPT-5.3 Codex" },
+      { id: "gpt-5.2", name: "GPT-5.2" },
+      { id: "gemini-3.1-pro", name: "Gemini 3.1 Pro" },
+      { id: "gemini-3-pro", name: "Gemini 3 Pro" },
+      { id: "gemini-3-flash", name: "Gemini 3 Flash" },
+      { id: "grok", name: "Grok" },
+      { id: "kimi-k2.5", name: "Kimi K2.5" },
+    ];
+  }
+
+  invalidateCache(): void {
+    this.cache = null;
+  }
+}

package/src/models/index.ts

@@ -0,0 +1,3 @@
+export { ModelDiscoveryService } from "./discovery.js";
+export { ConfigUpdater } from "./config.js";
+export type { ModelInfo, DiscoveryConfig } from "./types.js";

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);
+}