cursor-opencode-provider 0.2.9 → 0.3.1

package/dist/language-model.js

@@ -5,8 +5,8 @@ import { bidiRunStream, CursorRunInterruptedError, normalizeAgentRunOrigin, } fr
 import { trace, traceRequestContextPaths } from "./debug.js";
 import { buildRunRequest, buildHeartbeat } from "./protocol/request.js";
 import { decodeFramePayload } from "./protocol/framing.js";
-import { decodeMessage } from "./protocol/messages.js";
-import { parseExecServerMessage, buildToolCallPart, buildExecClientMessages, buildReadRejectionMessages, classifyMissingReadTarget, resolveReadTargetPath, parseExecIdFromToolCallId, detectExecVariantField, buildRequestContextResult, buildMcpStateResult, buildCustomWebToolAliases, extractHostSubagentCatalog, resolveCustomWebToolAlias, remapNativeSubagentForCatalog, CUSTOM_WEBFETCH_TOOL, CUSTOM_WEBSEARCH_TOOL, } from "./protocol/tools.js";
+import { debugWalkTurnEnded, decodeMessage } from "./protocol/messages.js";
+import { parseExecServerMessage, buildToolCallPart, buildExecClientMessages, buildReadRejectionMessages, classifyMissingReadTarget, resolveReadTargetPath, parseExecIdFromToolCallId, detectExecVariantField, buildRequestContextResult, buildMcpStateResult, buildCustomWebToolAliases, extractHostSubagentCatalog, resolveCustomWebToolAlias, remapNativeSubagentForCatalog, remapEditToolsForCatalog, CUSTOM_WEBFETCH_TOOL, CUSTOM_WEBSEARCH_TOOL, } from "./protocol/tools.js";
 import { describeCursorExecVariant } from "./protocol/exec-variants.js";
 import { advertisedToolNamesFromDescriptors, extractExecDisplayCallId, extractProtobufSubmessage, listProtobufFieldNumbers, parseDisplayToolCall, resolveBridgedOpenCodeToolCall, } from "./protocol/tool-call-bridge.js";
 import { handleKvServerMessage } from "./protocol/kv.js";
@@ -22,9 +22,12 @@ import { workspaceRootFromRequestContext } from "./context/env.js";
 import { opencodeGlobalCacheDir, setHostCacheDirOverride } from "./context/paths.js";
 import { resolveAgentUrl } from "./agent-url.js";
 import { CURSOR_API_HOST, CURSOR_COMPACTION_OPTION } from "./shared.js";
+import { isCompactionSession } from "./compaction-marker.js";
+import { getSessionDirectory } from "./session-directory.js";
 import { consumeCursorShellResult, registerCursorShellCall, } from "./shell-timeout.js";
 import { analyzeReplayFrame, AttemptReplaySafety } from "./replay-safety.js";
 import { readAllFieldsStrict } from "./protocol/struct.js";
+import { buildLanguageModelV3UsageFromEstimate, buildLanguageModelV3UsageFromTurnEnded, turnEndedCounter, } from "./usage.js";
 let _availableModels;
 // mtime of the cache file the last time we loaded it. Compared on each call
 // so discoverModels' background refresh is picked up without a process restart.
@@ -275,7 +278,7 @@ export function createCursorLanguageModel(modelId, providerId, options) {
     };
 }
 async function doStreamImpl(modelId, options, callOptions) {
-    // A raw `sk-...` API key must be exchanged for a JWT before it can be used
+    // A raw `crsr_...` API key must be exchanged for a JWT before it can be used
     // as a Bearer token (the plugin path does this in auth.ts). The accessToken
     // path is already a JWT from OAuth/key-exchange, so we use it as-is.
     // resolveBearerToken caches apiKey exchanges so we don't hit /auth/exchange
@@ -445,8 +448,10 @@ async function startSession(modelId, token, callOptions, options, startOptions)
     const sessionKey = opencodeSessionKey(callOptions);
     const providerOptions = callOptions.providerOptions?.cursor;
     // The classic plugin marks OpenCode's agent="compaction" through chat.params.
+    // OpenCode 2.0 removed that hook, so its plugin records the same fact against
+    // the session id from session.hook("context") instead; consult both.
     // Do not infer this from tools/toolChoice: standalone no-tool calls are valid.
-    const isCompaction = providerOptions?.[CURSOR_COMPACTION_OPTION] === true;
+    const isCompaction = providerOptions?.[CURSOR_COMPACTION_OPTION] === true || isCompactionSession(sessionKey);
     const toolState = resolveTurnToolState({
         sessionKey,
         incomingTools,
@@ -482,7 +487,12 @@ async function startSession(modelId, token, callOptions, options, startOptions)
     const userText = recovery?.kind === "rebase"
         ? "Continue the interrupted turn from the conversation history above. Do not repeat completed work."
         : (extractUserText([...prompt].reverse().find((m) => m.role === "user")) || ".");
-    const workspaceRoot = path.resolve(options.workspaceRoot || process.cwd());
+    // v1 sets `options.workspaceRoot` correctly per invocation (`input.directory`,
+    // one plugin instance per project). OpenCode 2.0 runs one daemon across many
+    // projects, so its static `options.workspaceRoot` is only a last-resort
+    // fallback; `getSessionDirectory` carries the real per-session directory
+    // recorded from `session.hook("context")` in `plugin-opencode2.ts`.
+    const workspaceRoot = path.resolve(getSessionDirectory(sessionKey) ?? (options.workspaceRoot || process.cwd()));
     const baseSystemPrompt = extractSystemPrompt(prompt);
     const interactionGuidance = buildOpenCodeInteractionGuidance(cursorTools, isCompaction, workspaceRoot);
     const systemPrompt = interactionGuidance
@@ -583,6 +593,7 @@ async function startSession(modelId, token, callOptions, options, startOptions)
         outputTokens: 0,
         cacheRead: 0,
         cacheWrite: 0,
+        reasoningTokens: 0,
     };
     trace(`outbound Run: model=${cursorModelId} opencodeModel=${modelId} conversationId=${conversationId} ` +
         `params=${JSON.stringify(parameterValues ?? [])} ` +
@@ -730,6 +741,7 @@ export function deliverContinuationResults(session, trailingToolResults) {
                     toolName: pending.toolName ?? r.toolName,
                     resultMetadata: pending.resultMetadata,
                     shellOutcome: shellResult?.outcome,
+                    workspaceRoot: workspaceRootFromRequestContext(session.requestContext),
                 });
             }
             catch (error) {
@@ -916,6 +928,7 @@ export async function pump(session, controller, ids, abortSignal) {
                 error: reason,
                 toolName: parsed.toolName,
                 resultMetadata: parsed.resultMetadata,
+                workspaceRoot: workspaceRootFromRequestContext(session.requestContext),
             })) {
                 session.stream.write(frame);
             }
@@ -941,7 +954,9 @@ export async function pump(session, controller, ids, abortSignal) {
         if (!displayCallId ||
             parsed.resultField !== "read_result" ||
             parsed.toolName !== "read" ||
-            !advertisedToolNameSet.has("write"))
+            // `apply_patch` is the substitute this host offers when it withholds
+            // `write` — the follow-up write_args is remapped onto it either way.
+            !(advertisedToolNameSet.has("write") || advertisedToolNameSet.has("apply_patch")))
             return false;
         const stored = session.displayToolCalls.get(displayCallId);
         const display = parseDisplayToolCall(displayCallId, stored);
@@ -965,6 +980,7 @@ export async function pump(session, controller, ids, abortSignal) {
                 output: "",
                 toolName: parsed.toolName,
                 resultMetadata: { path: requestedPath },
+                workspaceRoot,
             })) {
                 session.stream.write(frame);
             }
@@ -1067,32 +1083,27 @@ export async function pump(session, controller, ids, abortSignal) {
         if (te) {
             // Authoritative TurnEnded counts — replace the running estimate.
             session.usageEstimate = {
-                inputTokens: Number(te.input_tokens ?? 0) || 0,
-                outputTokens: Number(te.output_tokens ?? 0) || 0,
-                cacheRead: Number(te.cache_read ?? 0) || 0,
-                cacheWrite: Number(te.cache_write ?? 0) || 0,
+                inputTokens: turnEndedCounter(te, "input_tokens"),
+                outputTokens: turnEndedCounter(te, "output_tokens"),
+                cacheRead: turnEndedCounter(te, "cache_read"),
+                cacheWrite: turnEndedCounter(te, "cache_write"),
+                reasoningTokens: turnEndedCounter(te, "reasoning_tokens"),
             };
         }
         const est = session.usageEstimate;
-        const usage = {
-            inputTokens: {
-                total: promptTokens,
-                noCache: undefined,
-                cacheRead: 0,
-                cacheWrite: 0,
-            },
-            outputTokens: {
-                total: estimateTokens(requestUsage.outputChars),
-                text: undefined,
-                reasoning: undefined,
-            },
-        };
+        const usage = te
+            ? buildLanguageModelV3UsageFromTurnEnded(te)
+            : buildLanguageModelV3UsageFromEstimate(est, promptTokens, requestUsage.outputChars, estimateTokens);
         const providerMetadata = te ? cursorTurnEndedProviderMetadata(te) : undefined;
         const reasonLabel = typeof reason === "object" && reason && "unified" in reason
             ? String(reason.unified ?? "unknown")
             : String(reason);
+        const inTotal = usage.inputTokens?.total ?? 0;
+        const outTotal = usage.outputTokens?.total ?? 0;
         trace(`finish: reason=${reasonLabel} ` +
-            `requestIn=${usage.inputTokens.total} requestOut=${usage.outputTokens.total} ` +
+            `v3In=${inTotal} v3Out=${outTotal} ` +
+            `v3CacheRead=${usage.inputTokens?.cacheRead ?? 0} v3CacheWrite=${usage.inputTokens?.cacheWrite ?? 0} ` +
+            `v3Reasoning=${usage.outputTokens?.reasoning ?? 0} ` +
             `rawIn=${est.inputTokens} rawOut=${est.outputTokens} ` +
             `rawCacheRead=${est.cacheRead} rawCacheWrite=${est.cacheWrite} ` +
             `source=${te ? "turn_ended" : "estimate"}`);
@@ -1238,6 +1249,7 @@ export async function pump(session, controller, ids, abortSignal) {
                 emitReasoning(iu.thinking_delta.text ?? "");
             }
             else if (iu?.turn_ended) {
+                trace(`turn_ended raw wire fields: ${debugWalkTurnEnded(payload)}`);
                 emitFinish(iu.turn_ended, { unified: "stop", raw: undefined });
                 sessionManager.close(session);
                 return;
@@ -1367,6 +1379,10 @@ export async function pump(session, controller, ids, abortSignal) {
                             parsed.toolName = executableToolName;
                         }
                         remapNativeSubagentForCatalog(parsed, advertisedToolNameSet, session.subagentCatalog);
+                        // Hosts that advertise `apply_patch` in place of `edit`/`write` (see
+                        // protocol/apply-patch.ts) still receive Cursor's native write/edit
+                        // exec requests. Translate before the unavailable-tool check below.
+                        remapEditToolsForCatalog(parsed, advertisedToolNameSet, workspaceRootFromRequestContext(session.requestContext));
                     }
                     const displayCallId = extractExecDisplayCallId(esm);
                     trace(`exec: id=${parsed?.id} variant=${parsed ? Object.keys(parsed).join(",") : "none"} toolName=${parsed?.toolName} resultField=${parsed?.resultField}`);
@@ -1653,6 +1669,12 @@ export function buildOpenCodeInteractionGuidance(tools, isCompaction, workspaceR
             ? "- For file changes, use OpenCode `edit` for targeted changes to existing files and `write` to create files or intentionally replace complete contents; do not use shell, Python, or heredocs to change file content while these tools are available."
             : "- Use OpenCode `write` for file-content changes; do not use shell, Python, or heredocs to change file content while it is available.");
     }
+    else if (names.has("apply_patch")) {
+        // This host withheld `edit`/`write` and offers `apply_patch` instead. Native
+        // Cursor write/edit requests are translated into it, so say so rather than
+        // leaving the turn with no file-editing guidance at all.
+        instructions.push("- Use OpenCode `apply_patch` for file-content changes; do not use shell, Python, or heredocs to change file content while it is available. Cursor-native write and edit requests are accepted and converted to `apply_patch` automatically.");
+    }
     return [
         `OpenCode exposes exactly these executable tools for this turn: ${[...names].map((name) => `\`${name}\``).join(", ")}.`,
         `Workspace root: ${JSON.stringify(workspaceRoot)}. Resolve workspace paths against exactly this root; never invent an absolute prefix, and verify uncertain paths with an available tool before using them.`,
@@ -1683,20 +1705,14 @@ export function estimatePromptTokens(prompt) {
 }
 /** Preserve cumulative Cursor counters as diagnostics, never as AI SDK request usage. */
 export function cursorTurnEndedProviderMetadata(te) {
-    const counter = (key) => {
-        const value = te[key];
-        return typeof value === "number" && Number.isFinite(value) && value >= 0
-            ? Math.trunc(value)
-            : 0;
-    };
     return {
         cursor: {
             usageVersion: 2,
-            inputTokensRaw: counter("input_tokens"),
-            outputTokensRaw: counter("output_tokens"),
-            cacheReadRaw: counter("cache_read"),
-            cacheWriteRaw: counter("cache_write"),
-            reasoningTokensRaw: counter("reasoning_tokens"),
+            inputTokensRaw: turnEndedCounter(te, "input_tokens"),
+            outputTokensRaw: turnEndedCounter(te, "output_tokens"),
+            cacheReadRaw: turnEndedCounter(te, "cache_read"),
+            cacheWriteRaw: turnEndedCounter(te, "cache_write"),
+            reasoningTokensRaw: turnEndedCounter(te, "reasoning_tokens"),
         },
     };
 }

package/dist/model-config.d.ts

@@ -0,0 +1,15 @@
+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>;

package/dist/model-config.js

@@ -0,0 +1,206 @@
+import { CURSOR_VARIANT_PARAMETERS_KEY, CURSOR_WIRE_MODEL_ID_KEY, parseCursorContextLimit, } from "./models.js";
+/**
+ * Cursor `ModelInfo` → OpenCode model-config mapping.
+ *
+ * Host-neutral on purpose: both the classic/1.18 plugins and the OpenCode 2.0
+ * plugin derive their catalogs from here, so model naming, thinking suffixes,
+ * and long-context tiering stay identical across every surface. Do not import
+ * a host plugin API into this module.
+ */
+/**
+ * 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 stripMarkupTags(value) {
+    const chunks = [];
+    let cursor = 0;
+    while (cursor < value.length) {
+        const start = value.indexOf("<", cursor);
+        if (start === -1) {
+            chunks.push(value.slice(cursor));
+            break;
+        }
+        chunks.push(value.slice(cursor, start));
+        const end = value.indexOf(">", start + 1);
+        if (end === -1) {
+            chunks.push(value.slice(start));
+            break;
+        }
+        cursor = end + 1;
+    }
+    return chunks.join("");
+}
+function safeLabel(value) {
+    return (stripMarkupTags(value)
+        .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;
+}

package/dist/opencode2/catalog.d.ts

@@ -0,0 +1,33 @@
+import { type ModelInfo } from "../models.js";
+import type { CatalogDraft } from "./types.js";
+/**
+ * Catalog registration for the OpenCode 2.0 plugin — the replacement for the
+ * classic plugin's `config` hook.
+ *
+ * Model naming, thinking suffixes, and long-context tiering are NOT reimplemented
+ * here: we run the shared `modelsToConfig` and translate its output into the 2.0
+ * `Model.Info` shape, so every surface exposes an identical model list.
+ */
+/** Integration id owning Cursor credentials. Matches the provider id. */
+export declare const CURSOR_INTEGRATION_ID = "cursor";
+/**
+ * `aisdk:` selects OpenCode 2.0's AI SDK path, which is what surfaces the
+ * `aisdk.hook("sdk")` / `("language")` extension points we supply the provider
+ * through. The suffix is this package's npm name so the host's built-in
+ * `DynamicProviderPlugin` can still resolve it if our own hook is ever
+ * bypassed — that fallback runs `npm.add(pkg)` against the *published*
+ * registry into `<host-cache>/packages/<pkg>/node_modules/<pkg>`, ignoring
+ * any local `file://` plugin path this process was loaded from.
+ *
+ * `CURSOR_OPENCODE2_DEV_ENTRY` overrides the suffix with an `aisdk:file://…`
+ * spec instead, pointed at a local built entry file (e.g. `dist/index.js`,
+ * which exports `createCursor`). The host's fallback recognizes `file://`
+ * specs and imports them directly, skipping `npm.add` — the only way to
+ * exercise a local build through that fallback path short of publishing.
+ * Unset in production; only meant for local `opencode2 run` testing.
+ */
+export declare const CURSOR_AISDK_PACKAGE: string;
+/** Register (or update) the Cursor provider entry. `update` is an upsert. */
+export declare function applyCursorProvider(draft: CatalogDraft): void;
+/** Register every discovered Cursor model. Safe to re-run; `update` upserts. */
+export declare function applyCursorModels(draft: CatalogDraft, models: ModelInfo[]): void;

package/dist/opencode2/catalog.js

@@ -0,0 +1,85 @@
+import { pathToFileURL } from "node:url";
+import { CURSOR_PROVIDER_ID } from "../shared.js";
+import { CURSOR_WIRE_MODEL_ID_KEY } from "../models.js";
+import { modelsToConfig } from "../model-config.js";
+/**
+ * Catalog registration for the OpenCode 2.0 plugin — the replacement for the
+ * classic plugin's `config` hook.
+ *
+ * Model naming, thinking suffixes, and long-context tiering are NOT reimplemented
+ * here: we run the shared `modelsToConfig` and translate its output into the 2.0
+ * `Model.Info` shape, so every surface exposes an identical model list.
+ */
+/** Integration id owning Cursor credentials. Matches the provider id. */
+export const CURSOR_INTEGRATION_ID = CURSOR_PROVIDER_ID;
+/**
+ * `aisdk:` selects OpenCode 2.0's AI SDK path, which is what surfaces the
+ * `aisdk.hook("sdk")` / `("language")` extension points we supply the provider
+ * through. The suffix is this package's npm name so the host's built-in
+ * `DynamicProviderPlugin` can still resolve it if our own hook is ever
+ * bypassed — that fallback runs `npm.add(pkg)` against the *published*
+ * registry into `<host-cache>/packages/<pkg>/node_modules/<pkg>`, ignoring
+ * any local `file://` plugin path this process was loaded from.
+ *
+ * `CURSOR_OPENCODE2_DEV_ENTRY` overrides the suffix with an `aisdk:file://…`
+ * spec instead, pointed at a local built entry file (e.g. `dist/index.js`,
+ * which exports `createCursor`). The host's fallback recognizes `file://`
+ * specs and imports them directly, skipping `npm.add` — the only way to
+ * exercise a local build through that fallback path short of publishing.
+ * Unset in production; only meant for local `opencode2 run` testing.
+ */
+export const CURSOR_AISDK_PACKAGE = process.env.CURSOR_OPENCODE2_DEV_ENTRY
+    ? `aisdk:${pathToFileURL(process.env.CURSOR_OPENCODE2_DEV_ENTRY).href}`
+    : "aisdk:cursor-opencode-provider";
+/** Register (or update) the Cursor provider entry. `update` is an upsert. */
+export function applyCursorProvider(draft) {
+    draft.provider.update(CURSOR_PROVIDER_ID, (provider) => {
+        provider.id = CURSOR_PROVIDER_ID;
+        provider.name = "Cursor";
+        provider.package = CURSOR_AISDK_PACKAGE;
+        // Links the provider to the integration that stores its credentials, so
+        // `connection.active(...)` resolves the token the user set up via /connect.
+        provider.integrationID = CURSOR_INTEGRATION_ID;
+    });
+}
+/** Translate one `modelsToConfig` entry into the 2.0 `Model.Info` shape. */
+function applyModelEntry(draft, id, entry) {
+    const options = entry.options;
+    // Long-context entries get a synthetic OpenCode id (`<id>-1m`) while still
+    // addressing the same Cursor model on the wire. V1 smuggled that through
+    // provider options; 2.0 has a first-class `modelID` for exactly this.
+    const wireId = typeof options?.[CURSOR_WIRE_MODEL_ID_KEY] === "string"
+        ? options[CURSOR_WIRE_MODEL_ID_KEY]
+        : id;
+    const variants = Object.entries((entry.variants ?? {})).map(([variantId, settings]) => ({ id: variantId, settings: { ...settings } }));
+    draft.model.update(CURSOR_PROVIDER_ID, id, (model) => {
+        model.id = id;
+        model.modelID = wireId;
+        model.providerID = CURSOR_PROVIDER_ID;
+        model.name = entry.name;
+        model.capabilities = {
+            tools: entry.tool_call !== false,
+            // The provider does not convert file/image prompt parts, so text-only is
+            // the honest declaration. Revisit alongside Cursor's `supports_images`.
+            input: ["text"],
+            output: ["text"],
+        };
+        model.limit = { context: entry.limit.context, output: entry.limit.output };
+        model.variants = variants;
+        model.status = "active";
+        model.enabled = true;
+        model.time = { released: 0 };
+        model.cost = [];
+        // Carries the default variant parameters (and the wire id) through to
+        // doStream as provider options, matching the classic plugin.
+        if (options)
+            model.settings = { ...options };
+    });
+}
+/** Register every discovered Cursor model. Safe to re-run; `update` upserts. */
+export function applyCursorModels(draft, models) {
+    const config = modelsToConfig(models);
+    for (const [id, entry] of Object.entries(config)) {
+        applyModelEntry(draft, id, entry);
+    }
+}

package/dist/opencode2/integration.d.ts

@@ -0,0 +1,23 @@
+import type { CredentialValue, IntegrationDomain, IntegrationDraft } from "./types.js";
+/**
+ * Integration registration for the OpenCode 2.0 plugin — the replacement for the
+ * classic plugin's `auth` hook (`methods` + `loader`).
+ *
+ * Unlike the 1.18 v2 API (where OAuth registration is Effect-valued), 2.0 takes
+ * plain Promises, so the PKCE flow from `src/auth.ts` ports across unchanged.
+ */
+export declare const CURSOR_OAUTH_METHOD_ID = "oauth";
+/** Env vars that can supply a Cursor API key without running /connect. */
+export declare const CURSOR_ENV_NAMES: string[];
+/** Register the Cursor integration and its three connection methods. */
+export declare function applyCursorIntegration(draft: IntegrationDraft): void;
+/**
+ * Turn a stored credential into a Cursor access token.
+ *
+ * OAuth credentials already hold a JWT (the host refreshes them via `refresh`
+ * above). A `key` credential is the raw `crsr_…` API key, which Cursor requires us
+ * to exchange for a short-lived JWT — mirroring the classic plugin's behavior.
+ */
+export declare function accessTokenFromCredential(credential: CredentialValue | undefined): Promise<string | undefined>;
+/** Resolve the active Cursor connection into an access token, if any. */
+export declare function resolveCursorAccessToken(integration: IntegrationDomain): Promise<string | undefined>;