cursor-opencode-provider 0.7.3 → 0.7.4

package/dist/language-model.js

@@ -3406,7 +3406,7 @@ export function buildOpenCodeInteractionGuidance(tools, isCompaction, workspaceR
         instructions.push(shell
             ? `- OpenCode \`execute\` is Code Mode JavaScript (\`code\`); it is not a shell. For OS commands, call OpenCode ${shell}. Do not pass \`command\` to \`execute\`.`
             : "- OpenCode `execute` is Code Mode JavaScript (`code`); it is not a shell. Do not pass `command` to `execute`.");
-        instructions.push("- When the host's Code Mode catalog lists additional tools, including MCP server tools, call them inside `execute` through `tools`. Use only the exact paths and signatures in that catalog or returned by its `search` function. Call `execute` with `{ code }` to run them; do not request a Code Mode tool as a direct OpenCode tool call.");
+        instructions.push("- Call tools named in the direct list by their own names, even when a server instruction says to reach them through `execute`. Use `execute` only for tools that appear in the host Code Mode catalog and are absent from that list. Use the exact paths and signatures from that catalog or its `search` function, and call `execute` with `{ code }`.");
     }
     if (names.has("task") || names.has("subagent")) {
         const target = names.has("task") ? "`task`" : "`subagent`";

package/dist/opencode2/mcp-direct.d.ts

@@ -0,0 +1,26 @@
+import type { ToolDraft } from "./types.js";
+/**
+ * OpenCode 2 puts an MCP server's tools in Code Mode unless that server's
+ * config sets `codemode: false` (`packages/schema/src/mcp.ts`, applied in
+ * `packages/core/src/tool/mcp.ts`). Only `options.codemode === false` joins
+ * the AI SDK catalog (`packages/core/src/tool.ts`). Cursor can call a tool
+ * only when it is in that catalog.
+ *
+ * `config.codemode` is also the remote-connection switch: while it is not
+ * false, OpenCode appends `?codemode=false` so servers that bundle their own
+ * Code Mode return individual tools (`packages/core/src/mcp/client.ts`).
+ * This module therefore leaves server config alone and clears the tool option
+ * instead. An explicit server `codemode: true` stays in Code Mode. OpenCode's
+ * own namespaced tools (the `opencode` namespace) are not MCP servers and are
+ * left alone.
+ *
+ * The tool registry is location-scoped, so this placement is shared by every
+ * provider in the process. `"codemode": true` on a server is the per-server
+ * way to keep that server inside `execute`.
+ */
+export declare function mcpServerNamespace(server: string): string;
+export declare function rememberDirectMcpNamespaces(target: Set<string>, servers: readonly (readonly [string, {
+    readonly codemode?: boolean;
+}])[]): void;
+/** Move tools from the recorded MCP namespaces onto the direct catalog. */
+export declare function exposeDirectMcpTools(editor: ToolDraft, namespaces: ReadonlySet<string>): void;

package/dist/opencode2/mcp-direct.js

@@ -0,0 +1,60 @@
+/**
+ * OpenCode 2 puts an MCP server's tools in Code Mode unless that server's
+ * config sets `codemode: false` (`packages/schema/src/mcp.ts`, applied in
+ * `packages/core/src/tool/mcp.ts`). Only `options.codemode === false` joins
+ * the AI SDK catalog (`packages/core/src/tool.ts`). Cursor can call a tool
+ * only when it is in that catalog.
+ *
+ * `config.codemode` is also the remote-connection switch: while it is not
+ * false, OpenCode appends `?codemode=false` so servers that bundle their own
+ * Code Mode return individual tools (`packages/core/src/mcp/client.ts`).
+ * This module therefore leaves server config alone and clears the tool option
+ * instead. An explicit server `codemode: true` stays in Code Mode. OpenCode's
+ * own namespaced tools (the `opencode` namespace) are not MCP servers and are
+ * left alone.
+ *
+ * The tool registry is location-scoped, so this placement is shared by every
+ * provider in the process. `"codemode": true` on a server is the per-server
+ * way to keep that server inside `execute`.
+ */
+export function mcpServerNamespace(server) {
+    return server.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+export function rememberDirectMcpNamespaces(target, servers) {
+    target.clear();
+    // The editor exposes normalized namespaces, not server ownership. Keep
+    // ambiguous namespaces in their host-selected placement: otherwise a server
+    // named `opencode` moves builtins too, or `my.docs` overrides an explicit
+    // Code Mode choice on `my_docs`. Exclusions must win regardless of order.
+    const excluded = new Set(["opencode"]);
+    for (const [name, config] of servers) {
+        const namespace = mcpServerNamespace(name);
+        if (config.codemode === true)
+            excluded.add(namespace);
+        else
+            target.add(namespace);
+    }
+    for (const namespace of excluded)
+        target.delete(namespace);
+}
+/** Move tools from the recorded MCP namespaces onto the direct catalog. */
+export function exposeDirectMcpTools(editor, namespaces) {
+    if (namespaces.size === 0 || !editor.list || !editor.update)
+        return;
+    for (const tool of editor.list()) {
+        const namespace = tool.options?.namespace;
+        if (!namespace || !namespaces.has(namespace))
+            continue;
+        if (tool.options?.codemode === false)
+            continue;
+        editor.update(tool.id, (draft) => {
+            const options = {};
+            if (draft.options?.namespace !== undefined)
+                options.namespace = draft.options.namespace;
+            if (draft.options?.permission !== undefined)
+                options.permission = draft.options.permission;
+            options.codemode = false;
+            draft.options = options;
+        });
+    }
+}

package/dist/opencode2/types.d.ts

@@ -223,6 +223,15 @@ export type ToolDraft = {
     list?(): readonly (ToolDefinition & {
         readonly id: string;
     })[];
+    /** Host ToolEditor.update — missing ids are ignored. */
+    update?(id: string, update: (tool: {
+        options?: {
+            namespace?: string;
+            permission?: string;
+            codemode?: boolean;
+            pinned?: boolean;
+        };
+    }) => void): void;
 };
 export type ToolHookBaseFields = {
     readonly tool: string;
@@ -368,6 +377,20 @@ export type WebSearchDomain = {
     readonly transform: Transform<WebSearchEditor>;
     readonly reload: () => Promise<void>;
 };
+/**
+ * MCP config reader this plugin uses. Server `codemode` is observed and not
+ * written: writing it also changes the remote raw-tool URL. The host
+ * `MCPEditor` is a superset.
+ */
+export type McpServerConfig = {
+    readonly codemode?: boolean;
+};
+export type McpEditor = {
+    list(): readonly (readonly [string, McpServerConfig])[];
+};
+export type McpDomain = {
+    readonly transform: Transform<McpEditor>;
+};
 export type PluginLocation = {
     readonly directory: string;
 };
@@ -381,6 +404,7 @@ export type PluginContext = {
     readonly location?: PluginLocation;
     readonly shell?: ShellDomain;
     readonly websearch?: WebSearchDomain;
+    readonly mcp?: McpDomain;
 };
 export type Cleanup = () => Promise<void> | void;
 export type Plugin2 = {

package/dist/plugin-opencode2.js

@@ -8,6 +8,7 @@ import { fetchOpenCodeWebSearchText, parseExaWebSearchResults, } from "./web-too
 import { captureCursorShellResult, cursorShellEnvForCommand, prepareCursorShellArgs, releaseCursorShellEnv, sanitizeRegisteredCursorShellOutput, } from "./shell-timeout.js";
 import { applyCursorProviderInventory, CURSOR_INTEGRATION_ID } from "./opencode2/catalog.js";
 import { applyCursorIntegration, resolveCursorAccessToken } from "./opencode2/integration.js";
+import { exposeDirectMcpTools, rememberDirectMcpNamespaces } from "./opencode2/mcp-direct.js";
 import { registerTodoTools } from "./opencode2/todo-tools.js";
 import { OPENCODE_2_TOOL_DIALECT } from "./protocol/tools.js";
 import { clearSessionTodos } from "./todo-store.js";
@@ -250,12 +251,25 @@ const plugin = {
                 });
             }));
         }
+        // Namespaces whose tools belong on the direct catalog. Filled by the MCP
+        // transform (config is not written) and read when tool transforms replay,
+        // including after a later MCP discovery reload.
+        const directMcpNamespaces = new Set();
+        if (ctx.mcp) {
+            await track(ctx.mcp.transform((editor) => {
+                rememberDirectMcpNamespaces(directMcpNamespaces, editor.list());
+            }));
+        }
         await track(ctx.tool.transform((draft) => {
             // OpenCode 2 dropped host todowrite/todoread. Off by default
             // (`CURSOR_OPENCODE2_TODOS=1`/`true` force-enables). When on, register
             // them as direct catalog tools (`codemode: false` + output schema) if
             // the host does not already own those names. When off, register none.
             registerTodoTools(draft);
+            // MCP tools default into Code Mode. Move every server that did not
+            // explicitly opt in onto the direct catalog so Cursor can call them
+            // by name. See `opencode2/mcp-direct.ts`.
+            exposeDirectMcpTools(draft, directMcpNamespaces);
         }));
         // ── Shell timeout wrapper ────────────────────────────────
         await track(ctx.tool.hook("execute.before", (event) => {

package/package.json

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