cursor-opencode-provider 0.2.9 → 0.3.1

package/dist/plugin-opencode2.js

@@ -0,0 +1,293 @@
+import { CURSOR_PROVIDER_ID } from "./shared.js";
+import { createSdk, cursorApiBaseURL, cursorGetServerConfigTelemetryEnabled, isCursorPackage } from "./plugin-core.js";
+import { adoptCompatHostCacheDir, opencodeGlobalCacheDir } from "./context/paths.js";
+import { discoverModels, isCacheFresh, readCache } from "./models.js";
+import { resolveAgentUrl } from "./agent-url.js";
+import { sessionActivity } from "./activity.js";
+import { fetchOpenCodeWebSearchText } from "./web-tools.js";
+import { captureCursorShellResult, cursorShellOriginalCommand, prepareCursorShellArgs, releaseCursorShellEnv, sanitizeRegisteredCursorShellOutput, } from "./shell-timeout.js";
+import { applyCursorModels, applyCursorProvider } from "./opencode2/catalog.js";
+import { applyCursorIntegration, resolveCursorAccessToken } from "./opencode2/integration.js";
+import { markCompactionSession } from "./compaction-marker.js";
+import { markSessionDirectory } from "./session-directory.js";
+/**
+ * OpenCode 2.0 beta plugin.
+ *
+ * Separate from `plugin-v2.ts` on purpose: the OpenCode 1.18 `/v2/promise` API
+ * and the 2.0 API are source-incompatible (hook signatures, OAuth value type,
+ * provider schema), so they cannot share an entrypoint. Shared behavior lives in
+ * `plugin-core.ts`, `model-config.ts`, and `opencode2/*`.
+ *
+ * Load with:  { "plugins": ["cursor-opencode-provider/plugin/opencode2"] }
+ */
+async function loadModels(cacheDir, accessToken) {
+    const cached = await readCache(cacheDir);
+    if (cached?.models.length && isCacheFresh(cached))
+        return cached.models;
+    if (accessToken) {
+        try {
+            return await discoverModels(accessToken, cacheDir, { baseURL: cursorApiBaseURL() });
+        }
+        catch {
+            // Fall through to stale-on-failure below.
+        }
+    }
+    // Preserve offline / stale-cache behavior rather than emptying the picker.
+    return cached?.models ?? [];
+}
+const plugin = {
+    id: "cursor.provider",
+    setup: async (ctx) => {
+        // Prefer OCP HostProfile.cacheDir when present; else XDG host heuristic.
+        await adoptCompatHostCacheDir();
+        const cacheDir = opencodeGlobalCacheDir();
+        const registrations = [];
+        const track = async (p) => {
+            registrations.push(await p);
+        };
+        let models = [];
+        // ── Credentials ──────────────────────────────────────────────────────────
+        await track(ctx.integration.transform(applyCursorIntegration));
+        let cachedToken;
+        let tokenInflight;
+        /**
+         * Cache only a *successful* resolution.
+         *
+         * On a fresh install `setup()` runs before the user has connected, so the
+         * first attempt necessarily returns nothing. Memoizing that would pin the
+         * plugin to "no credentials" for the whole process and models would never
+         * load, even after a successful /connect.
+         */
+        const accessToken = async () => {
+            if (cachedToken)
+                return cachedToken;
+            tokenInflight ??= resolveCursorAccessToken(ctx.integration).finally(() => {
+                tokenInflight = undefined;
+            });
+            const token = await tokenInflight;
+            if (token)
+                cachedToken = token;
+            return token;
+        };
+        // ── Catalog ──────────────────────────────────────────────────────────────
+        // Runs now with whatever models we have (likely none) and is replayed by the
+        // host on every `catalog.reload()`, so the async fill below just re-triggers it.
+        await track(ctx.catalog.transform((draft) => {
+            applyCursorProvider(draft);
+            applyCursorModels(draft, models);
+        }));
+        // ── AI SDK wiring ────────────────────────────────────────────────────────
+        await track(ctx.aisdk.hook("sdk", async (event) => {
+            if (event.sdk)
+                return;
+            if (!isCursorPackage(event.package, event.model.providerID))
+                return;
+            const token = await accessToken();
+            event.sdk = createSdk({
+                name: event.model.providerID || CURSOR_PROVIDER_ID,
+                ...(token ? { accessToken: token } : {}),
+                // Static fallback only. This hook fires once per model/package, not
+                // per session, and 2.0 runs one daemon across many projects — the
+                // real per-request directory comes from the session.context hook
+                // below via `getSessionDirectory`, which `language-model.ts` prefers.
+                workspaceRoot: process.cwd(),
+                cacheDir,
+                ...event.options,
+            });
+        }));
+        await track(ctx.aisdk.hook("language", (event) => {
+            if (event.language)
+                return;
+            if (event.model.providerID !== CURSOR_PROVIDER_ID)
+                return;
+            if (typeof event.sdk?.languageModel !== "function")
+                return;
+            // `modelID` is the Cursor wire id; `id` may be a synthetic long-context entry.
+            event.language = event.sdk.languageModel(event.model.modelID || event.model.id);
+        }));
+        // ── Web search ───────────────────────────────────────────────────────────
+        // Registered as a tool, matching the classic plugin. 2.0 also has a
+        // first-class `websearch` domain, but its Result shape is structured
+        // ({url, title?, content?}) while the Exa backend here returns an opaque
+        // text blob — mapping one to the other would mean guessing Exa's payload
+        // shape, so the tool form stays until that can be verified against a live
+        // response.
+        await track(ctx.tool.transform((draft) => {
+            draft.add({
+                name: "custom_websearch",
+                description: "Search the web for current information using OpenCode's web search backend.",
+                input: {
+                    type: "object",
+                    properties: {
+                        query: { type: "string", description: "Web search query" },
+                        numResults: { type: "integer", minimum: 1, maximum: 20 },
+                        livecrawl: { type: "string", enum: ["fallback", "preferred"] },
+                        type: { type: "string", enum: ["auto", "fast", "deep"] },
+                        contextMaxCharacters: { type: "integer", exclusiveMinimum: 0 },
+                    },
+                    required: ["query"],
+                    additionalProperties: false,
+                },
+                execute: async (input, context) => {
+                    const output = await fetchOpenCodeWebSearchText(input, context?.abort);
+                    return {
+                        title: `Exa Web Search: ${input.query}`,
+                        output,
+                        metadata: { provider: "exa" },
+                    };
+                },
+            });
+        }));
+        // ── Shell timeout wrapper ────────────────────────────────────────────────
+        await track(ctx.tool.hook("execute.before", (event) => {
+            if (event.tool !== "bash")
+                return;
+            // No `shell.env` in 2.0 → always use the wrapper-file command form.
+            prepareCursorShellArgs(event.callID, event.input, {
+                preferWrapperCommand: true,
+            });
+        }));
+        await track(ctx.tool.hook("execute.after", (event) => {
+            if (event.tool !== "bash")
+                return;
+            try {
+                if (event.status !== "completed")
+                    return;
+                const result = event.result;
+                result.title = cursorShellOriginalCommand(event.callID) ?? result.title;
+                result.output = captureCursorShellResult(event.callID, result.output, result.metadata);
+                if (result.metadata && typeof result.metadata === "object") {
+                    const metadata = result.metadata;
+                    if (typeof metadata.output === "string") {
+                        metadata.output = sanitizeRegisteredCursorShellOutput(event.callID, metadata.output);
+                    }
+                }
+            }
+            finally {
+                releaseCursorShellEnv(event.callID);
+            }
+        }));
+        // ── Compaction marker + session directory ───────────────────────────────
+        // 2.0 removed `chat.params`, and `session.hook("context")` exposes no
+        // provider-options channel — only `system`/`messages`/`tools` are mutable.
+        // But it does name the owning agent and the session id, and the provider
+        // already derives the same session id from request headers, so record
+        // both facts here and let doStream read them back via
+        // `isCompactionSession` / `getSessionDirectory`.
+        await track(ctx.session.hook("context", async (event) => {
+            markCompactionSession(event.sessionID, event.agent === "compaction");
+            try {
+                const info = await ctx.session.get({ sessionID: event.sessionID });
+                markSessionDirectory(event.sessionID, info.location?.directory);
+            }
+            catch {
+                // Best effort — falls back to the static workspaceRoot above.
+            }
+        }));
+        // ── Model discovery ──────────────────────────────────────────────────────
+        // Idempotent and cheap once satisfied, so it is safe to call from anywhere
+        // that might mark the moment credentials became available.
+        let modelsLoaded = false;
+        let ensureInflight;
+        const ensureModels = () => {
+            if (modelsLoaded)
+                return Promise.resolve();
+            ensureInflight ??= (async () => {
+                try {
+                    const token = await accessToken();
+                    const discovered = await loadModels(cacheDir, token);
+                    if (!discovered.length)
+                        return;
+                    models = discovered;
+                    modelsLoaded = true;
+                    // Replays the catalog transform above, this time with models.
+                    await ctx.catalog.reload().catch(() => { });
+                    if (token) {
+                        // Resolve the region-specific Run origin so the first turn doesn't
+                        // pay for GetServerConfig. Best effort: startSession surfaces real
+                        // failures.
+                        await resolveAgentUrl(token, {
+                            apiBaseURL: cursorApiBaseURL(),
+                            telemetryEnabled: cursorGetServerConfigTelemetryEnabled(),
+                        }).catch(() => { });
+                    }
+                }
+                finally {
+                    ensureInflight = undefined;
+                }
+            })();
+            return ensureInflight;
+        };
+        // On a fresh install the user connects *after* startup, and the host has no
+        // "connection established" hook we can key on. Poll briefly so models show
+        // up within seconds of /connect instead of requiring a restart. The window
+        // is bounded; after it, any session/message event still triggers a retry.
+        const RETRY_INTERVAL_MS = 3_000;
+        const RETRY_WINDOW_MS = 300_000;
+        const startedAt = Date.now();
+        const retry = setInterval(() => {
+            if (modelsLoaded || Date.now() - startedAt > RETRY_WINDOW_MS) {
+                clearInterval(retry);
+                return;
+            }
+            void ensureModels();
+        }, RETRY_INTERVAL_MS);
+        retry.unref?.();
+        void ensureModels();
+        // ── Session activity ─────────────────────────────────────────────────────
+        // Doubles as a retry trigger: any host activity after the polling window has
+        // closed still gets one more chance to pick up newly-added credentials.
+        const unsubscribe = subscribeSessionActivity(ctx, ensureModels);
+        return async () => {
+            clearInterval(retry);
+            unsubscribe?.();
+            for (const registration of registrations.reverse()) {
+                await registration.dispose().catch(() => { });
+            }
+        };
+    },
+};
+/** Feed OpenCode session/message events into the shared activity tracker. */
+function subscribeSessionActivity(ctx, onEvent) {
+    try {
+        const stream = ctx.event.subscribe();
+        if (!stream || typeof stream[Symbol.asyncIterator] !== "function")
+            return undefined;
+        let stopped = false;
+        void (async () => {
+            for await (const event of stream) {
+                if (stopped)
+                    break;
+                applySessionActivity(event);
+                onEvent?.();
+            }
+        })().catch(() => { });
+        return () => {
+            stopped = true;
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function applySessionActivity(event) {
+    switch (event?.type) {
+        case "session.created":
+            sessionActivity.linkSession(event.properties.info.id, event.properties.info.parentID);
+            sessionActivity.recordActivity(event.properties.info.id);
+            break;
+        case "session.updated":
+            sessionActivity.linkSession(event.properties.info.id, event.properties.info.parentID);
+            break;
+        case "session.deleted":
+            sessionActivity.removeSession(event.properties.info.id);
+            break;
+        case "message.updated":
+            sessionActivity.recordActivity(event.properties.info.sessionID);
+            break;
+        case "message.part.updated":
+            sessionActivity.recordActivity(event.properties.part.sessionID);
+            break;
+    }
+}
+export default plugin;

package/dist/plugin-v2.d.ts

@@ -1,2 +1,9 @@
+/**
+ * OpenCode Effect / Promise v2 plugin.
+ *
+ * Wires the Cursor provider through `ctx.aisdk.sdk` / `ctx.aisdk.language`
+ * (the V2 extension points). Auth still lives in the classic Hooks plugin
+ * (`plugin.ts`) until OpenCode integrations fully replace provider OAuth.
+ */
 declare const _default: import("@opencode-ai/plugin/v2/promise").Plugin;
 export default _default;

package/dist/plugin-v2.js

@@ -1,6 +1,6 @@
 import { define } from "@opencode-ai/plugin/v2/promise";
 import { CURSOR_PROVIDER_ID } from "./shared.js";
-import { createCursorLanguageModel } from "./language-model.js";
+import { createSdk, isCursorPackage } from "./plugin-core.js";
 import { adoptCompatHostCacheDir } from "./context/paths.js";
 /**
  * OpenCode Effect / Promise v2 plugin.
@@ -9,20 +9,6 @@ import { adoptCompatHostCacheDir } from "./context/paths.js";
  * (the V2 extension points). Auth still lives in the classic Hooks plugin
  * (`plugin.ts`) until OpenCode integrations fully replace provider OAuth.
  */
-function isCursorPackage(pkg, providerID) {
-    if (providerID === CURSOR_PROVIDER_ID)
-        return true;
-    return (pkg.includes("cursor-opencode-provider") ||
-        /cursor-opencode-provider[/\\]dist[/\\]index\.js/.test(pkg));
-}
-function createSdk(options) {
-    const providerId = options.name || CURSOR_PROVIDER_ID;
-    return {
-        languageModel(modelId) {
-            return createCursorLanguageModel(modelId, providerId, options);
-        },
-    };
-}
 export default define({
     id: "cursor.provider",
     setup: async (ctx) => {

package/dist/plugin.d.ts

@@ -1,17 +1,3 @@
 import type { Hooks, PluginInput } from "@opencode-ai/plugin";
-import { type ModelInfo } from "./models.js";
-/**
- * Display names shared by both a thinking and a non-thinking model. A thinking
- * model with such a name needs a "Thinking" tag to disambiguate it from its
- * non-thinking twin (Cursor's Claude/Fable/Sonnet families). Models whose names
- * are already unique — including Cursor's GPT family, where the reasoning tier
- * ("None"/"Low"/"High"…) is baked into the name — are excluded, so they aren't
- * tagged redundantly.
- */
-export declare function thinkingSuffixBaseNames(models: ModelInfo[]): Set<string>;
-export declare function modelInfoToConfig(mi: ModelInfo, options?: {
-    thinkingSuffix?: boolean;
-    contextTier?: "base" | "long";
-}): Record<string, any>;
-export declare function modelsToConfig(models: ModelInfo[]): Record<string, any>;
+export { modelInfoToConfig, modelsToConfig, thinkingSuffixBaseNames } from "./model-config.js";
 export declare function CursorPlugin(input: PluginInput): Promise<Hooks>;

package/dist/plugin.js

@@ -1,199 +1,19 @@
 import { CURSOR_COMPACTION_OPTION, CURSOR_PROVIDER_ID, CURSOR_WEBSITE_HOST, CURSOR_API_HOST } from "./shared.js";
+import { cursorApiBaseURL, cursorGetServerConfigTelemetryEnabled } from "./plugin-core.js";
 import { pollForTokens, exchangeApiKey, refreshAccessToken, isExpiringSoon, generatePkceParams, generatePkceChallenge, buildLoginUrl, decodeJwtExpiryMs } from "./auth.js";
-import { CURSOR_VARIANT_PARAMETERS_KEY, CURSOR_WIRE_MODEL_ID_KEY, readCache, discoverModels, isCacheFresh, parseCursorContextLimit } from "./models.js";
+import { readCache, discoverModels, isCacheFresh } from "./models.js";
+// Re-exported for API compatibility: tests and downstream code import these
+// from "./plugin.js". Canonical home is ./model-config.ts, which stays free of
+// host plugin imports so the OpenCode 2.0 entrypoint can share it.
+import { modelsToConfig } from "./model-config.js";
+export { modelInfoToConfig, modelsToConfig, thinkingSuffixBaseNames } from "./model-config.js";
 import { adoptCompatHostCacheDir, opencodeGlobalCacheDir } from "./context/paths.js";
 import { readStoredAuth } from "./context/auth-store.js";
 import { resolveAgentUrl } from "./agent-url.js";
 import { captureCursorShellResult, cursorShellEnvForCall, cursorShellOriginalCommand, prepareCursorShellArgs, releaseCursorShellEnv, sanitizeRegisteredCursorShellOutput, setCursorShellPath, } from "./shell-timeout.js";
 import { sessionActivity } from "./activity.js";
-import { openCodeWebSearchTool } from "./web-tools.js";
+import { openCodeWebSearchTool } from "./web-search-tool.js";
 const MODULE_URL = new URL("./index.js", import.meta.url).href;
-/**
- * Strip characters and markup that break rendering in the OpenCode TUI/GUI from
- * a model or variant display name:
- *   • HTML tags (e.g. `<span style="…">Medium</span>`) — the IDE colours variant
- *     suffixes with a CSS var that doesn't exist in OpenCode, so the raw markup
- *     would show as literal text. We drop the tags and keep the inner text
- *     ("Medium").
- *   • HTML/markup chars (`< > & " ' \``), parentheses.
- *   • Tabs/newlines collapse to single spaces.
- * Dots and unicode letters are preserved so names stay readable.
- * Fixes https://github.com/oakimov/cursor-opencode-provider/issues/2.
- */
-function safeLabel(value) {
-    return (value
-        .replace(/<[^>]+>/g, "")
-        .replace(/[()<>&"'`]/g, "")
-        .replace(/\s+/g, " ")
-        .trim() || "default");
-}
-function baseName(mi) {
-    return safeLabel(mi.displayName ?? mi.id);
-}
-function modelInfoVariants(mi, variants) {
-    if (variants.length === 0)
-        return undefined;
-    const entries = {};
-    const usedKeys = new Set();
-    const baseName = safeLabel(mi.displayName ?? mi.id);
-    // Each variant's key is `safeLabel(displayName)` (the IDE's own label, e.g.
-    // "Opus 4.8 1M High Fast Thinking") so the picker matches what the user
-    // sees in Cursor. Two variants can sanitize to the same name when the IDE
-    // wraps a differentiator in `<span>…</span>` (e.g. Composer's "Fast"
-    // suffix collapses to the bare model name after stripping). To guarantee
-    // every variant stays pickable:
-    //   1. If the sanitized displayName matches the model name itself, suffix
-    //      it with distinguishing params (or "default") so it never collides
-    //      with the model entry in the variant panel.
-    //   2. If two variants still collide, tag the later one with its params.
-    // Suffixes must stay free of `()` / markup chars — same constraint as
-    // safeLabel (issue #2); use spaced tokens, not parenthetical tags.
-    const tagDims = (p) => {
-        const labels = [];
-        for (const d of p) {
-            if (d.id === "fast" && d.value === "true")
-                labels.push("Fast");
-            else if (d.id === "thinking" && d.value === "true")
-                labels.push("Thinking");
-            else if (d.id === "context")
-                labels.push(d.value);
-        }
-        if (labels.length > 0)
-            return ` ${labels.join(" ")}`;
-        // No params at all — still disambiguate from the model name itself.
-        if (p.length === 0)
-            return "";
-        return " default";
-    };
-    for (const v of variants) {
-        const sanitized = safeLabel(v.displayName || v.key || "default");
-        let key = sanitized;
-        // Never let a variant key equal the model name — that would make the
-        // variant entry indistinguishable from the model entry in pickers that
-        // collapse them.
-        if (key === baseName && !usedKeys.has(key)) {
-            key = `${baseName}${tagDims(v.parameterValues)}` || `${baseName} default`;
-        }
-        else if (usedKeys.has(key)) {
-            key = `${sanitized}${tagDims(v.parameterValues)}`;
-        }
-        let n = 2;
-        while (usedKeys.has(key))
-            key = `${sanitized}${tagDims(v.parameterValues)} ${n++}`;
-        usedKeys.add(key);
-        entries[key] = {
-            [CURSOR_VARIANT_PARAMETERS_KEY]: v.parameterValues.map((p) => ({ ...p })),
-        };
-    }
-    return entries;
-}
-function isLongContextVariant(v) {
-    return v.parameterValues.some((p) => p.id === "context" && parseCursorContextLimit(p.value) === 1_000_000);
-}
-function variantsForTier(mi, tier) {
-    return mi.variants.filter((v) => isLongContextVariant(v) === (tier === "long"));
-}
-/**
- * Display names shared by both a thinking and a non-thinking model. A thinking
- * model with such a name needs a "Thinking" tag to disambiguate it from its
- * non-thinking twin (Cursor's Claude/Fable/Sonnet families). Models whose names
- * are already unique — including Cursor's GPT family, where the reasoning tier
- * ("None"/"Low"/"High"…) is baked into the name — are excluded, so they aren't
- * tagged redundantly.
- */
-export function thinkingSuffixBaseNames(models) {
-    const flags = new Map();
-    for (const m of models) {
-        const base = baseName(m);
-        const entry = flags.get(base) ?? { hasThinking: false, hasNonThinking: false };
-        if (m.supportsThinking)
-            entry.hasThinking = true;
-        else
-            entry.hasNonThinking = true;
-        flags.set(base, entry);
-    }
-    const ambiguous = new Set();
-    for (const [base, f] of flags)
-        if (f.hasThinking && f.hasNonThinking)
-            ambiguous.add(base);
-    return ambiguous;
-}
-export function modelInfoToConfig(mi, options = {}) {
-    const contextTier = options.contextTier ?? "base";
-    const variants = variantsForTier(mi, contextTier);
-    let name = baseName(mi);
-    if (options.thinkingSuffix)
-        name += " Thinking";
-    if (contextTier === "long")
-        name += " 1M";
-    // OpenCode's context limit is static per model entry, while Cursor's context
-    // tier is a variant parameter. Long-context choices are therefore emitted as
-    // separate OpenCode entries by modelsToConfig.
-    const context = contextTier === "long"
-        ? (mi.maxContextForMaxMode ?? 1_000_000)
-        : (mi.maxContext ?? 200_000);
-    // OpenCode's overflow/compaction/UI use limit.context; generation and
-    // thinking budgets use limit.output. models.dev 1M peers advertise
-    // 64k–128k output — a tiny cap makes long-context sessions feel broken
-    // even when the 1M input window is correct.
-    const output = contextTier === "long" ? 128_000 : 32_000;
-    const config = {
-        name,
-        reasoning: mi.supportsThinking ?? false,
-        tool_call: mi.supportsAgent ?? true,
-        temperature: false,
-        limit: {
-            context,
-            output,
-        },
-    };
-    const variantConfig = modelInfoVariants(mi, variants);
-    if (variantConfig)
-        config.variants = variantConfig;
-    if (contextTier === "long") {
-        const defaultVariant = variants.find((v) => v.isDefaultMax) ?? variants[0];
-        if (defaultVariant) {
-            config.options = {
-                [CURSOR_WIRE_MODEL_ID_KEY]: mi.id,
-                [CURSOR_VARIANT_PARAMETERS_KEY]: defaultVariant.parameterValues.map((p) => ({ ...p })),
-            };
-        }
-    }
-    return config;
-}
-export function modelsToConfig(models) {
-    const ambiguous = thinkingSuffixBaseNames(models);
-    const out = {};
-    const usedIds = new Set(models.map((m) => m.id));
-    for (const m of models) {
-        const thinkingSuffix = !!m.supportsThinking && ambiguous.has(baseName(m));
-        const baseVariants = variantsForTier(m, "base");
-        const longVariants = variantsForTier(m, "long");
-        if (baseVariants.length > 0 || longVariants.length === 0) {
-            out[m.id] = modelInfoToConfig(m, { thinkingSuffix, contextTier: "base" });
-        }
-        if (longVariants.length === 0)
-            continue;
-        if (baseVariants.length === 0) {
-            out[m.id] = modelInfoToConfig(m, { thinkingSuffix, contextTier: "long" });
-            continue;
-        }
-        let longId = `${m.id}-1m`;
-        let suffix = 2;
-        while (usedIds.has(longId))
-            longId = `${m.id}-1m-${suffix++}`;
-        usedIds.add(longId);
-        out[longId] = modelInfoToConfig(m, { thinkingSuffix, contextTier: "long" });
-    }
-    return out;
-}
-function cursorApiBaseURL() {
-    return process.env.CURSOR_API_BASE_URL ?? `https://${CURSOR_API_HOST}`;
-}
-function cursorGetServerConfigTelemetryEnabled() {
-    return (process.env.CURSOR_GET_SERVER_CONFIG_TELEMETRY === "1" ||
-        process.env.CURSOR_GET_SERVER_CONFIG_TELEMETRY === "true");
-}
 export async function CursorPlugin(input) {
     // Prefer strong OCP host identity when available; otherwise resolve from explicit host signals/install path.
     await adoptCompatHostCacheDir();
@@ -443,10 +263,10 @@ export async function CursorPlugin(input) {
                             type: "text",
                             key: "apiKey",
                             message: "Cursor API key",
-                            placeholder: "sk-...",
+                            placeholder: "crsr_...",
                             validate(value) {
-                                if (!value.startsWith("sk-"))
-                                    return "API key should start with sk-";
+                                if (!value.startsWith("crsr_"))
+                                    return "API key should start with crsr_";
                                 return undefined;
                             },
                         },