cursor-opencode-provider 0.2.2 → 0.2.3

package/README.md

@@ -240,7 +240,7 @@ OpenCode
 
 - **Personal use / ToS** — this provider speaks Cursor’s private agent protocol (CLI-shaped client identity). Use only with an account you own; Cursor may change or restrict the API without notice.
 - **`request_context` from OpenCode** — each Run sends Cursor `RequestContext` built from OpenCode project context (workspace env, `AGENTS.md` / `instructions`, `.opencode` agents/skills/plugins, git, layout, plus `.claude`/`.agents` skill fallbacks). Same discovery as OpenCode — including `.cursor/` paths only when listed in `instructions`. Cursor-only cloud/sandbox marketplace surfaces are omitted.
-- **Configured MCP tools keep their upstream server id** — OpenCode builtins and plugin/custom tools are advertised under a synthetic `opencode` MCP server. Tools whose flattened name matches an MCP server in merged `opencode.json` configuration (`github_create_pull_request`, …) are grouped into that server's `mcp_descriptors` / `provider_identifier` (`github`, …). Unknown underscore-containing names stay under `opencode` rather than being guessed incorrectly. Exec still reconstructs the full OpenCode tool id.
+- **Configured MCP tools keep their upstream server id** — OpenCode builtins and plugin/custom tools are advertised under a synthetic `opencode` MCP server. Tools whose flattened name matches an MCP server in merged `opencode.json` configuration (`github_create_pull_request`, …) are grouped into that server's `mcp_descriptors` / `provider_identifier` (`github`, …). Unknown underscore-containing names stay under `opencode` rather than being guessed incorrectly. Cursor's MCP-state exec probe is answered from the same advertised descriptors before the actual tool request, and exec still reconstructs the full OpenCode tool id.
 - **Display completions are notifications, not execution requests** — Cursor `tool_call_*` frames use a typed `ToolCall` oneof. The provider decodes them for diagnostics but only mirrors finalized todo/plan state (`update_todos_tool_call` / `create_plan_tool_call`) into advertised OpenCode `todowrite`; the completed payload already contains the authoritative final list. Interactive, data-returning, and side-effecting completions are never replayed as new tools because their result could not be returned to Cursor. Exec-backed Pi read/bash/edit/write/grep/find/ls calls use their typed request/result fields instead. Unknown display variants are logged; unknown exec variants fail the turn explicitly rather than receiving a guessed response that could deadlock the Run.
 - **Cursor-native interaction queries remain headless** — Cursor UI/approval *queries* (as distinct from display tool calls) still cannot be surfaced through the AI SDK provider interface. The normal system prompt redirects questions, planning, plan-mode transitions, and known-URL fetching to equivalent OpenCode tools only when they are advertised (`question`, `todowrite`, `plan_enter` / `plan_exit`, `webfetch`); native web/PR/MCP/image/SCM requests are declined so they remain behind OpenCode's tools and permissions. Compaction prompts are unchanged. Unknown future interaction variants fail the turn explicitly instead of hanging the Run stream.
 - **Compaction resets Cursor conversation state** — the classic plugin marks OpenCode's `compaction` agent explicitly. On those turns the provider mints an isolated Cursor `conversation_id`, drops the prior checkpoint + KV blobs, preserves real tool-result text in the seed history, and re-advertises the session's last tool catalog while refusing execution during the summary itself. The first normal turn then rebases once more onto a fresh conversation seeded with OpenCode's compacted prompt and normal system instructions, so the summary-agent checkpoint cannot suppress later tool calls. Ordinary no-tool / `toolChoice:none` calls do not reset conversation state.

package/dist/language-model.js

@@ -5,7 +5,7 @@ import { trace } 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, } from "./protocol/tools.js";
+import { parseExecServerMessage, buildToolCallPart, buildExecClientMessages, parseExecIdFromToolCallId, detectExecVariantField, buildRequestContextResult, buildMcpStateResult, } from "./protocol/tools.js";
 import { advertisedToolNamesFromDescriptors, extractExecDisplayCallId, extractProtobufSubmessage, listProtobufFieldNumbers, parseDisplayToolCall, resolveBridgedOpenCodeToolCall, } from "./protocol/tool-call-bridge.js";
 import { handleKvServerMessage } from "./protocol/kv.js";
 import { handleInteractionQuery, inspectInteractionQueryWire } from "./protocol/interactions.js";
@@ -751,6 +751,26 @@ export async function pump(session, controller, ids, abortSignal) {
                         trace(`exec request_context: write FAILED ${e.message}`);
                     }
                 }
+                else if (esm.mcp_state_exec_args) {
+                    // MCP-backed writes/reads can be preceded by this control-plane probe.
+                    // Confirm the virtual servers from the already-advertised context, then
+                    // keep pumping until Cursor emits the actual mcp_args tool request.
+                    const stateArgs = esm.mcp_state_exec_args;
+                    const requested = Array.isArray(stateArgs.server_identifiers)
+                        ? stateArgs.server_identifiers.join(",")
+                        : "";
+                    try {
+                        session.stream.write(buildMcpStateResult(esmId, stateArgs, session.requestContext));
+                        trace(`exec mcp_state: replied id=${esmId} requested=[${requested}]`);
+                    }
+                    catch (e) {
+                        const error = new Error(`Failed to answer Cursor MCP state probe: ${e.message}`);
+                        trace(`exec mcp_state: write FAILED ${error.message}`);
+                        safeError(error);
+                        sessionManager.close(session);
+                        return;
+                    }
+                }
                 else {
                     const parsed = parseExecServerMessage(esm);
                     const displayCallId = extractExecDisplayCallId(esm);

package/dist/protocol/messages.js

@@ -657,6 +657,37 @@ export function createMessageTypes() {
     addType(root, "RequestContextResult", [
         { id: 1, name: "success", type: "RequestContextSuccess" },
     ]);
+    // Cursor probes MCP server availability before emitting an MCP-backed tool
+    // call. OpenCode owns those servers, so answer from the descriptors already
+    // advertised in RequestContext rather than surfacing this as a user tool.
+    addType(root, "McpStateExecArgs", [
+        { id: 1, name: "server_identifiers", type: "string", repeated: true },
+        { id: 2, name: "kick_only", type: "bool" },
+    ]);
+    addType(root, "McpInstructions", [
+        { id: 1, name: "server_name", type: "string" },
+        { id: 2, name: "instructions", type: "string" },
+        { id: 3, name: "server_identifier", type: "string" },
+    ]);
+    addType(root, "McpStateServer", [
+        { id: 1, name: "server_name", type: "string" },
+        { id: 2, name: "server_identifier", type: "string" },
+        { id: 3, name: "plugin", type: "string" },
+        { id: 4, name: "marketplace", type: "string" },
+        { id: 5, name: "tools", type: "McpFsToolDescriptor", repeated: true },
+        { id: 6, name: "instructions", type: "McpInstructions", repeated: true },
+        { id: 7, name: "status", type: "string" },
+    ]);
+    addType(root, "McpStateSuccess", [
+        { id: 1, name: "servers", type: "McpStateServer", repeated: true },
+    ]);
+    addType(root, "McpStateError", [{ id: 1, name: "error", type: "string" }]);
+    addType(root, "McpStateRejected", [{ id: 1, name: "reason", type: "string" }]);
+    addType(root, "McpStateExecResult", [
+        { id: 1, name: "success", type: "McpStateSuccess" },
+        { id: 2, name: "error", type: "McpStateError" },
+        { id: 3, name: "rejected", type: "McpStateRejected" },
+    ], [{ name: "result", fields: ["success", "error", "rejected"] }]);
     // ExecServerMessage — server asks us to execute a tool
     addType(root, "ExecServerMessage", [
         { id: 1, name: "id", type: "uint32" },
@@ -670,6 +701,7 @@ export function createMessageTypes() {
         { id: 10, name: "request_context_args", type: "RequestContextArgs" },
         { id: 11, name: "mcp_args", type: "McpArgs" },
         { id: 14, name: "shell_stream_args", type: "ShellArgs" },
+        { id: 36, name: "mcp_state_exec_args", type: "McpStateExecArgs" },
         { id: 45, name: "pi_read_args", type: "PiReadToolArgs" },
         { id: 46, name: "pi_bash_args", type: "PiBashToolArgs" },
         { id: 47, name: "pi_edit_args", type: "PiEditToolArgs" },
@@ -679,7 +711,7 @@ export function createMessageTypes() {
         { id: 51, name: "pi_ls_args", type: "PiLsToolArgs" },
     ], [{ name: "args", fields: [
                 "write_args", "delete_args", "grep_args", "read_args", "ls_args",
-                "request_context_args", "mcp_args", "shell_stream_args",
+                "request_context_args", "mcp_args", "shell_stream_args", "mcp_state_exec_args",
                 "pi_read_args", "pi_bash_args", "pi_edit_args", "pi_write_args",
                 "pi_grep_args", "pi_find_args", "pi_ls_args",
             ] }]);
@@ -696,6 +728,7 @@ export function createMessageTypes() {
         { id: 10, name: "request_context_result", type: "RequestContextResult" },
         { id: 11, name: "mcp_result", type: "McpResult" },
         { id: 14, name: "shell_stream", type: "ShellStream" },
+        { id: 36, name: "mcp_state_exec_result", type: "McpStateExecResult" },
         { id: 46, name: "pi_read_result", type: "PiReadExecResult" },
         { id: 47, name: "pi_bash_result", type: "PiBashExecResult" },
         { id: 48, name: "pi_edit_result", type: "PiEditExecResult" },
@@ -705,7 +738,7 @@ export function createMessageTypes() {
         { id: 52, name: "pi_ls_result", type: "PiLsExecResult" },
     ], [{ name: "result", fields: [
                 "write_result", "delete_result", "grep_result", "read_result", "ls_result",
-                "request_context_result", "mcp_result", "shell_stream",
+                "request_context_result", "mcp_result", "shell_stream", "mcp_state_exec_result",
                 "pi_read_result", "pi_bash_result", "pi_edit_result", "pi_write_result",
                 "pi_grep_result", "pi_find_result", "pi_ls_result",
             ] }]);

package/dist/protocol/tools.d.ts

@@ -142,3 +142,9 @@ export declare function detectExecVariantField(agentServerPayload: Uint8Array):
  * Encode exec #10 request_context_result from a prebuilt RequestContext payload.
  */
 export declare function buildRequestContextResult(execId: number, requestContext: Record<string, unknown>): Uint8Array;
+/**
+ * Answer Cursor's exec #36 MCP-state probe from the same descriptors advertised
+ * in RequestContext. OpenCode remains the executor; this only confirms that the
+ * provider's virtual MCP servers and their tools are available.
+ */
+export declare function buildMcpStateResult(execId: number, args: Record<string, unknown>, requestContext: Record<string, unknown>): Uint8Array;

package/dist/protocol/tools.js

@@ -810,3 +810,62 @@ export function buildRequestContextResult(execId, requestContext) {
         },
     });
 }
+/**
+ * Answer Cursor's exec #36 MCP-state probe from the same descriptors advertised
+ * in RequestContext. OpenCode remains the executor; this only confirms that the
+ * provider's virtual MCP servers and their tools are available.
+ */
+export function buildMcpStateResult(execId, args, requestContext) {
+    const requested = new Set(Array.isArray(args.server_identifiers)
+        ? args.server_identifiers.filter((id) => typeof id === "string" && id.length > 0)
+        : []);
+    const fsOptions = recordValue(requestContext.mcp_file_system_options);
+    const nested = Array.isArray(fsOptions?.mcp_descriptors)
+        ? fsOptions.mcp_descriptors.map(recordValue).filter((d) => !!d)
+        : [];
+    const descriptors = nested.length > 0 ? nested : descriptorsFromFlatTools(requestContext.tools);
+    const servers = descriptors
+        .filter((descriptor) => {
+        const id = stringValue(descriptor.server_identifier);
+        return requested.size === 0 || (id !== undefined && requested.has(id));
+    })
+        .map((descriptor) => ({
+        server_name: stringValue(descriptor.server_name) ?? stringValue(descriptor.server_identifier) ?? "",
+        server_identifier: stringValue(descriptor.server_identifier) ?? stringValue(descriptor.server_name) ?? "",
+        tools: Array.isArray(descriptor.tools) ? descriptor.tools : [],
+    }));
+    return encodeMessage("AgentClientMessage", {
+        exec_client_message: {
+            id: execId,
+            mcp_state_exec_result: { success: { servers } },
+        },
+    });
+}
+function recordValue(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function descriptorsFromFlatTools(value) {
+    if (!Array.isArray(value))
+        return [];
+    const byServer = new Map();
+    for (const raw of value) {
+        const tool = recordValue(raw);
+        if (!tool)
+            continue;
+        const server = stringValue(tool.provider_identifier) ?? "opencode";
+        const tools = byServer.get(server) ?? [];
+        tools.push({
+            tool_name: stringValue(tool.tool_name) ?? stringValue(tool.name) ?? "",
+            description: stringValue(tool.description) ?? "",
+            input_schema: tool.input_schema,
+        });
+        byServer.set(server, tools);
+    }
+    return [...byServer].map(([server, tools]) => ({
+        server_name: server,
+        server_identifier: server,
+        tools,
+    }));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cursor-opencode-provider",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Use Cursor subscription models from OpenCode via Cursor's Connect-RPC agent protocol",
   "type": "module",
   "license": "MIT",