cursor-opencode-provider 0.2.8 → 0.3.0

package/dist/context/paths.js

@@ -4,6 +4,30 @@ import { homedir } from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { trace } from "../debug.js";
+/** Host-neutral bridge installed by OCP before an unchanged provider is loaded. */
+export const OPENCODE_PATH_BRIDGE = Symbol.for("opencode.compat.path-bridge");
+function pathBridge() {
+    const value = globalThis[OPENCODE_PATH_BRIDGE];
+    if (!value || typeof value !== "object")
+        return undefined;
+    const bridge = value;
+    return typeof bridge.projectConfigDirs === "function" && typeof bridge.globalConfigDirs === "function"
+        ? bridge
+        : undefined;
+}
+export function opencodeProjectConfigDirs(workspaceRoot) {
+    return pathBridge()?.projectConfigDirs(path.resolve(workspaceRoot)) ?? [
+        path.join(path.resolve(workspaceRoot), ".opencode"),
+    ];
+}
+export function opencodeGlobalConfigDirs() {
+    return pathBridge()?.globalConfigDirs() ?? [opencodeGlobalConfigDir()];
+}
+export function opencodeConfigFileNames() {
+    return pathBridge()?.configFileNames?.length
+        ? [...pathBridge().configFileNames]
+        : ["opencode.json", "opencode.jsonc"];
+}
 /** Explicit host cache root (e.g. Effect v2 `Path.cache`, or `createCursor({ cacheDir })`). */
 let hostCacheDirOverride;
 function resolveHome(env = process.env) {

package/dist/context/plugins.js

@@ -1,6 +1,6 @@
 import { readdir, stat } from "node:fs/promises";
 import path from "node:path";
-import { opencodeGlobalConfigDir } from "./paths.js";
+import { opencodeGlobalConfigDirs, opencodeProjectConfigDirs } from "./paths.js";
 async function listLocalPlugins(dir) {
     try {
         await stat(dir);
@@ -34,17 +34,21 @@ export async function collectPlugins(workspaceRoot, config) {
         seen.add(id);
         out.push({ id, source: "npm" });
     }
-    for (const p of await listLocalPlugins(path.join(workspaceRoot, ".opencode", "plugins"))) {
-        if (seen.has(p.id))
-            continue;
-        seen.add(p.id);
-        out.push(p);
-    }
-    for (const p of await listLocalPlugins(path.join(opencodeGlobalConfigDir(), "plugins"))) {
-        if (seen.has(p.id))
-            continue;
-        seen.add(p.id);
-        out.push(p);
+    for (const configDir of opencodeProjectConfigDirs(workspaceRoot)) {
+        for (const p of await listLocalPlugins(path.join(configDir, "plugins"))) {
+            if (seen.has(p.id))
+                continue;
+            seen.add(p.id);
+            out.push(p);
+        }
+    }
+    for (const configDir of opencodeGlobalConfigDirs()) {
+        for (const p of await listLocalPlugins(path.join(configDir, "plugins"))) {
+            if (seen.has(p.id))
+                continue;
+            seen.add(p.id);
+            out.push(p);
+        }
     }
     return out;
 }

package/dist/context/rules.js

@@ -1,7 +1,7 @@
 import { readFile, readdir, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import path from "node:path";
-import { opencodeGlobalConfigDir, resolveHomeRelative } from "./paths.js";
+import { opencodeConfigFileNames, opencodeGlobalConfigDirs, opencodeProjectConfigDirs, resolveHomeRelative } from "./paths.js";
 async function exists(file) {
     try {
         await stat(file);
@@ -12,7 +12,7 @@ async function exists(file) {
     }
 }
 async function readJsonConfig(dir) {
-    for (const name of ["opencode.json", "opencode.jsonc"]) {
+    for (const name of opencodeConfigFileNames()) {
         const file = path.join(dir, name);
         if (!(await exists(file)))
             continue;
@@ -151,29 +151,30 @@ export async function fetchRemoteInstruction(url, timeoutMs = 5000) {
         clearTimeout(timer);
     }
 }
-export async function loadMergedConfig(workspaceRoot) {
-    const globalConfig = await readJsonConfig(opencodeGlobalConfigDir());
-    if (isProjectConfigDisabled()) {
-        return {
-            ...globalConfig,
-            instructions: [...(globalConfig.instructions ?? [])],
-            plugin: [...(globalConfig.plugin ?? [])],
-            plugins: [...(globalConfig.plugins ?? [])],
-            mcp: { ...(globalConfig.mcp ?? {}) },
-            permission: globalConfig.permission,
-        };
-    }
-    const projectConfig = await readJsonConfig(workspaceRoot);
+function mergeConfig(base, overlay) {
     return {
-        ...globalConfig,
-        ...projectConfig,
-        instructions: [...(globalConfig.instructions ?? []), ...(projectConfig.instructions ?? [])],
-        plugin: [...new Set([...(globalConfig.plugin ?? []), ...(projectConfig.plugin ?? [])])],
-        plugins: [...new Set([...(globalConfig.plugins ?? []), ...(projectConfig.plugins ?? [])])],
-        mcp: { ...(globalConfig.mcp ?? {}), ...(projectConfig.mcp ?? {}) },
-        permission: projectConfig.permission ?? globalConfig.permission,
+        ...base,
+        ...overlay,
+        instructions: [...(base.instructions ?? []), ...(overlay.instructions ?? [])],
+        plugin: [...new Set([...(base.plugin ?? []), ...(overlay.plugin ?? [])])],
+        plugins: [...new Set([...(base.plugins ?? []), ...(overlay.plugins ?? [])])],
+        mcp: { ...(base.mcp ?? {}), ...(overlay.mcp ?? {}) },
+        permission: overlay.permission ?? base.permission,
     };
 }
+export async function loadMergedConfig(workspaceRoot) {
+    const globalConfig = await readJsonConfig(opencodeGlobalConfigDirs()[0] ?? "");
+    if (isProjectConfigDisabled())
+        return mergeConfig({}, globalConfig);
+    // The bridge supplies native project config roots for an unchanged plugin:
+    // .opencode on OpenCode, .mimocode on MiMo, and .kilo/.kilocode on Kilo.
+    // Later roots have higher precedence, matching the host's native ordering.
+    let projectConfig = await readJsonConfig(workspaceRoot);
+    for (const configDir of opencodeProjectConfigDirs(workspaceRoot)) {
+        projectConfig = mergeConfig(projectConfig, await readJsonConfig(configDir));
+    }
+    return mergeConfig(globalConfig, projectConfig);
+}
 /**
  * Collect OpenCode instruction files.
  */
@@ -205,7 +206,9 @@ export async function collectRules(workspaceRoot) {
             }
         }
     }
-    await add(path.join(opencodeGlobalConfigDir(), "AGENTS.md"));
+    for (const globalDir of opencodeGlobalConfigDirs()) {
+        await add(path.join(globalDir, "AGENTS.md"));
+    }
     await add(path.join(homedir(), ".claude", "CLAUDE.md"));
     for (const raw of config.instructions ?? []) {
         if (raw.startsWith("http://") || raw.startsWith("https://")) {

package/dist/context/skills.js

@@ -1,7 +1,7 @@
 import { readdir, readFile, stat } from "node:fs/promises";
 import path from "node:path";
 import { homedir } from "node:os";
-import { opencodeGlobalConfigDir } from "./paths.js";
+import { opencodeGlobalConfigDirs, opencodeProjectConfigDirs } from "./paths.js";
 async function exists(p) {
     try {
         await stat(p);
@@ -94,8 +94,13 @@ async function walkAncestorsFor(dir, rel, stop, out) {
 export async function collectSkills(workspaceRoot, worktree) {
     const out = new Map();
     const home = homedir();
-    await walkAncestorsFor(workspaceRoot, path.join(".opencode", "skills"), worktree, out);
-    await scanSkillsRoot(path.join(opencodeGlobalConfigDir(), "skills"), out);
+    for (const projectDir of opencodeProjectConfigDirs(workspaceRoot)) {
+        const relative = path.relative(workspaceRoot, projectDir);
+        await walkAncestorsFor(workspaceRoot, path.join(relative, "skills"), worktree, out);
+    }
+    for (const globalDir of opencodeGlobalConfigDirs()) {
+        await scanSkillsRoot(path.join(globalDir, "skills"), out);
+    }
     await walkAncestorsFor(workspaceRoot, path.join(".claude", "skills"), worktree, out);
     await scanSkillsRoot(path.join(home, ".claude", "skills"), out);
     await walkAncestorsFor(workspaceRoot, path.join(".agents", "skills"), worktree, out);

package/dist/index.d.ts

@@ -34,9 +34,7 @@ export type CreateCursorOptions = {
     /** Fresh-turn retry policy. Defaults: 3 attempts, 500ms base, 8000ms cap. */
     retry?: CursorRetryOptions;
 };
-export declare function createCursor(options: CreateCursorOptions): {
-    languageModel(modelId: string): import("@ai-sdk/provider").LanguageModelV3;
-};
+export declare function createCursor(options: CreateCursorOptions): import("./plugin-core.js").CursorSdk;
 export { CursorPlugin };
 export type { CursorContinuationOptions, CursorContinuationPolicy } from "./session.js";
 export default CursorPlugin;

package/dist/index.js

@@ -1,13 +1,7 @@
-import { CURSOR_PROVIDER_ID } from "./shared.js";
-import { createCursorLanguageModel } from "./language-model.js";
+import { createSdk } from "./plugin-core.js";
 import { CursorPlugin } from "./plugin.js";
 export function createCursor(options) {
-    const providerId = options.name || CURSOR_PROVIDER_ID;
-    return {
-        languageModel(modelId) {
-            return createCursorLanguageModel(modelId, providerId, options);
-        },
-    };
+    return createSdk(options);
 }
 export { CursorPlugin };
 export default CursorPlugin;

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, parseExecIdFromToolCallId, detectExecVariantField, buildRequestContextResult, buildMcpStateResult, buildCustomWebToolAliases, resolveCustomWebToolAlias, 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, 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,
@@ -463,6 +468,7 @@ async function startSession(modelId, token, callOptions, options, startOptions)
         trace(`web tool alias: ${alias} -> ${original}`);
     }
     const allowTools = toolState.allowTools;
+    const discoveredSubagentCatalog = extractHostSubagentCatalog(cursorTools);
     const resetState = resolveTurnConversationReset({ sessionKey, isCompaction });
     const recovery = startOptions?.recovery;
     const resuming = recovery?.kind === "resume";
@@ -481,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
@@ -526,6 +537,23 @@ async function startSession(modelId, token, callOptions, options, startOptions)
         headers: options.headers,
     });
     const requestContext = await buildRequestContext({ workspaceRoot, tools: cursorTools });
+    const contextSubagents = Array.isArray(requestContext.custom_subagents)
+        ? requestContext.custom_subagents
+            .map((agent) => agent && typeof agent === "object" && typeof agent.name === "string"
+            ? {
+                name: agent.name,
+                description: typeof agent.description === "string"
+                    ? agent.description
+                    : undefined,
+            }
+            : undefined)
+            .filter((agent) => !!agent)
+        : [];
+    const subagentCatalog = {
+        ...discoveredSubagentCatalog,
+        agents: [...new Map([...discoveredSubagentCatalog.agents, ...contextSubagents]
+                .map((agent) => [agent.name, agent])).values()],
+    };
     // Resolve descriptors once from the merged OpenCode config so MCP identity is
     // consistent across AgentRunRequest and both request_context reply paths.
     const toolDescriptors = Array.isArray(requestContext.tools)
@@ -565,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 ?? [])} ` +
@@ -603,6 +632,7 @@ async function startSession(modelId, token, callOptions, options, startOptions)
         blobs: new Map(),
         toolDescriptors,
         toolAliases: webToolAliases.aliases,
+        subagentCatalog,
         requestContext,
         allowTools,
         usageEstimate,
@@ -711,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) {
@@ -897,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);
             }
@@ -946,6 +978,7 @@ export async function pump(session, controller, ids, abortSignal) {
                 output: "",
                 toolName: parsed.toolName,
                 resultMetadata: { path: requestedPath },
+                workspaceRoot,
             })) {
                 session.stream.write(frame);
             }
@@ -961,6 +994,49 @@ export async function pump(session, controller, ids, abortSignal) {
             return true;
         }
     };
+    /**
+     * A read of a path that does not exist would otherwise reach OpenCode as a
+     * real tool call and raise a permission prompt for a file the user never had.
+     * Cursor's own LocalReadExecutor instead resolves the target against the
+     * workspace, stats it, and returns a typed ReadResult (file_not_found /
+     * invalid_file) before execution. Mirror that here: reply on the held-open
+     * exec channel with the exact typed case so the model receives a structured
+     * observation and the host surfaces no prompt.
+     *
+     * Read-only by construction — write/edit targets are never checked, so
+     * legitimate file creation (path resolves, file absent) is never denied. Runs
+     * after recoverMissingEditRead, which has already converted the new-file edit
+     * handshake read into an empty-file success. EACCES/EPERM and other stat
+     * errors fall through to OpenCode so a genuine permission decision stands.
+     */
+    const rejectMissingReadTarget = (parsed) => {
+        if (parsed.toolName !== "read")
+            return false;
+        const requested = typeof parsed.args.filePath === "string" ? parsed.args.filePath : "";
+        if (!requested)
+            return false;
+        const workspaceRoot = workspaceRootFromRequestContext(session.requestContext);
+        const absolutePath = resolveReadTargetPath(requested, workspaceRoot);
+        const readResult = classifyMissingReadTarget(absolutePath);
+        if (!readResult)
+            return false;
+        try {
+            for (const frame of buildReadRejectionMessages(parsed.id, readResult)) {
+                session.stream.write(frame);
+            }
+            const kind = Object.keys(readResult)[0];
+            trace(`exec: rejected missing read target id=${parsed.id} kind=${kind} ` +
+                `path=${JSON.stringify(absolutePath)}`);
+            return true;
+        }
+        catch (e) {
+            const error = new Error(`Failed to reject Cursor read of a missing path: ${e.message}`);
+            trace(`exec: missing read rejection FAILED ${error.message}`);
+            safeError(error);
+            sessionManager.close(session);
+            return true;
+        }
+    };
     /** AI SDK V3 requires text-end / reasoning-end before finish or tool-call. */
     const closeOpenSpans = () => {
         for (const part of spanEndParts({ textStarted, reasoningStarted, textId, reasoningId })) {
@@ -1005,32 +1081,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"}`);
@@ -1176,6 +1247,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;
@@ -1304,6 +1376,7 @@ export async function pump(session, controller, ids, abortSignal) {
                             trace(`web tool alias resolved: ${parsed.toolName} -> ${executableToolName}`);
                             parsed.toolName = executableToolName;
                         }
+                        remapNativeSubagentForCatalog(parsed, advertisedToolNameSet, session.subagentCatalog);
                     }
                     const displayCallId = extractExecDisplayCallId(esm);
                     trace(`exec: id=${parsed?.id} variant=${parsed ? Object.keys(parsed).join(",") : "none"} toolName=${parsed?.toolName} resultField=${parsed?.resultField}`);
@@ -1344,6 +1417,11 @@ export async function pump(session, controller, ids, abortSignal) {
                         }
                         if (recoverMissingEditRead(parsed, displayCallId))
                             continue;
+                        if (rejectMissingReadTarget(parsed)) {
+                            if (displayCallId)
+                                session.displayToolCalls.delete(displayCallId);
+                            continue;
+                        }
                         if (displayCallId) {
                             session.displayToolCalls.delete(displayCallId);
                             trace(`exec: claimed display callId=${displayCallId}`);
@@ -1550,6 +1628,7 @@ export function buildOpenCodeInteractionGuidance(tools, isCompaction, workspaceR
     if (names.size === 0)
         return undefined;
     const instructions = [];
+    const subagents = extractHostSubagentCatalog(tools);
     if (names.has("question")) {
         instructions.push("- When user input is required, call the OpenCode `question` tool; do not use Cursor's native AskQuestion interaction.");
     }
@@ -1568,6 +1647,17 @@ export function buildOpenCodeInteractionGuidance(tools, isCompaction, workspaceR
     if (names.has(CUSTOM_WEBFETCH_TOOL)) {
         instructions.push(`- To fetch a known URL, call \`${CUSTOM_WEBFETCH_TOOL}\`; do not use Cursor's native WebFetch interaction.`);
     }
+    if (names.has("task") || names.has("actor")) {
+        const target = names.has("actor") ? "`actor`" : "`task`";
+        const available = subagents.agents.map((agent) => `\`${agent.name}\``).join(", ");
+        instructions.push(`- Native Cursor Task/subagent requests are executed through OpenCode ${target}. ` +
+            "Advertised custom subagent names are used exactly; otherwise `unspecified` and `generalPurpose` select host `general`, " +
+            "`bugbot`, `security-review`, and `explore` select host `explore` (then `general`), and other specialized Cursor types fall back to `general`." +
+            (available ? ` Spawnable host agents this turn: ${available}.` : ""));
+        if (subagents.agents.some((agent) => agent.name === "scout")) {
+            instructions.push("- Host `scout` is available for external documentation and dependency-source research. Use Cursor `cursor-guide` for that use case; local repository discovery still uses `bugbot`/`explore`.");
+        }
+    }
     if (names.has("write")) {
         instructions.push(names.has("edit")
             ? "- 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."
@@ -1576,7 +1666,9 @@ export function buildOpenCodeInteractionGuidance(tools, isCompaction, workspaceR
     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.`,
-        "Call only tools in that exact list. Cursor-native tools that are not listed—including Task/subagents—are unavailable; do not invoke them. If a capability is absent, complete the work directly with the listed tools or explain the limitation.",
+        subagents.executor
+            ? "Call only tools in that exact list. Cursor-native Task/subagent requests are permitted because a compatible host executor is listed; other unlisted Cursor-native tools remain unavailable."
+            : "Call only tools in that exact list. Cursor-native tools that are not listed—including Task/subagents—are unavailable; do not invoke them. If a capability is absent, complete the work directly with the listed tools or explain the limitation.",
         ...(instructions.length > 0
             ? ["Use these OpenCode tools instead of equivalent Cursor-native UI interactions:"]
             : []),
@@ -1601,20 +1693,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>;