cursor-opencode-provider 0.7.2 → 0.7.4

package/dist/model-config.js

@@ -154,9 +154,13 @@ export function modelInfoToConfig(mi, options = {}) {
     // tier is a variant parameter. Long-context choices are therefore emitted as
     // separate OpenCode entries by modelsToConfig.
     const documentedContext = getDocumentedCursorModelContext(mi.id);
+    // Cursor Auto (`default`) has no static maxContext on the model list, but
+    // live checkpoints report 256k for the base tier — the previous 200k
+    // fallback made the host context meter disagree with Cursor.
+    const fallbackContext = mi.id === "default" ? 256_000 : 200_000;
     const context = contextTier === "long"
         ? (mi.maxContextForMaxMode ?? documentedContext?.maxContextForMaxMode ?? 1_000_000)
-        : (mi.maxContext ?? documentedContext?.maxContext ?? 200_000);
+        : (mi.maxContext ?? documentedContext?.maxContext ?? fallbackContext);
     // 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

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,7 +8,9 @@ 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";
 import { markCompactionSession } from "./compaction-marker.js";
 import { markSessionDirectory } from "./session-directory.js";
@@ -213,11 +215,14 @@ const plugin = {
                 ...(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.
+                // real per-request directory comes from `x-opencode-directory` and
+                // the session.context hook below via `getSessionDirectory`.
                 workspaceRoot,
                 cacheDir,
                 ...event.options,
+                // Keep after `event.options` so the OC2 plugin always selects the
+                // `path`/`shell` dialect when advertised schemas are opaque.
+                defaultDialect: OPENCODE_2_TOOL_DIALECT,
             });
         }));
         await track(ctx.aisdk.hook("language", (event) => {
@@ -246,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) => {
@@ -324,8 +342,10 @@ const plugin = {
         }
         const rememberSessionDirectory = async (sessionID) => {
             try {
-                const info = await ctx.session.get({ sessionID });
-                markSessionDirectory(sessionID, info.location?.directory);
+                const info = (await ctx.session.get({ sessionID }));
+                // OpenCode 2.0 stable exposes a flat `directory`; older shapes nest it
+                // under `location.directory`. Prefer the flat field when both exist.
+                markSessionDirectory(sessionID, info.directory ?? info.location?.directory);
             }
             catch {
                 // Best effort — falls back to the static workspaceRoot above.

package/dist/plugin.js

@@ -17,6 +17,7 @@ import { sessionActivity } from "./activity.js";
 import { createOpenCodeWebSearchTool, openCodeWebSearchTool } from "./web-search-tool.js";
 import { createCursorImageSaveTool, cursorImageSaveTool } from "./image-save-tool.js";
 import { createPlanExecutionKickoffText, setPlanExecutionKickoff, } from "./plan-execution-kickoff.js";
+import { dispatchHostEventBridge } from "./host-event-bridge.js";
 const MODULE_URL = new URL("./index.js", import.meta.url).href;
 export async function loadClassicTools(options = {}) {
     const configDir = options.configDirs?.[0] ?? opencodeGlobalConfigDirs()[0];
@@ -56,21 +57,25 @@ export async function CursorPlugin(input) {
     const cacheDir = opencodeGlobalCacheDir();
     const apiBaseURL = cursorApiBaseURL();
     const classicTools = await loadClassicTools();
-    // After CreatePlan Yes, queue OpenCode's plan_exit-shaped synthetic turn so
-    // implementation starts. Failures stay in the kickoff module (trace only).
-    setPlanExecutionKickoff(async ({ sessionID, planPath }) => {
-        await input.client.session.promptAsync({
-            path: { id: sessionID },
-            body: {
-                agent: "build",
-                parts: [{
-                        type: "text",
-                        text: createPlanExecutionKickoffText(planPath),
-                        synthetic: true,
-                    }],
-            },
-        });
-    });
+    // Install the OpenCode plan-exit-shaped kickoff only when the OpenCode client
+    // exposes that structural API. Without it, no synthetic kickoff is registered.
+    const sessionClient = input.client?.session;
+    const promptAsync = sessionClient?.promptAsync;
+    setPlanExecutionKickoff(typeof promptAsync === "function"
+        ? async ({ sessionID, planPath }) => {
+            await promptAsync.call(sessionClient, {
+                path: { id: sessionID },
+                body: {
+                    agent: "build",
+                    parts: [{
+                            type: "text",
+                            text: createPlanExecutionKickoffText(planPath),
+                            synthetic: true,
+                        }],
+                },
+            });
+        }
+        : undefined);
     // Last access token successfully resolved in this plugin instance. Config's
     // loadModels can only read OpenCode's durable store (auth.json /
     // OPENCODE_AUTH_CONTENT); auth.loader gets live credentials via getAuth().
@@ -217,6 +222,12 @@ export async function CursorPlugin(input) {
                     sessionActivity.recordActivity(event.properties.part.sessionID);
                     break;
             }
+            await dispatchHostEventBridge({
+                event,
+                client: input.client,
+                directory: input.directory,
+                serverUrl: input.serverUrl,
+            });
         },
         async "tool.execute.before"(hookInput, output) {
             if (hookInput.tool !== "bash")

package/dist/pricing-data.d.ts

@@ -55,6 +55,12 @@ export declare const CURSOR_MODEL_COSTS: {
         readonly cache_read: 0.5;
         readonly cache_write: 6.25;
     };
+    readonly "claude-opus-5-5": {
+        readonly input: 4;
+        readonly output: 20;
+        readonly cache_read: 0.2;
+        readonly cache_write: 5;
+    };
     readonly "claude-sonnet-4": {
         readonly input: 3;
         readonly output: 15;
@@ -241,6 +247,26 @@ export declare const CURSOR_MODEL_COSTS: {
         readonly output: 12;
         readonly cache_read: 1;
     };
+    readonly "grok-4.7": {
+        readonly input: 2;
+        readonly output: 6;
+        readonly cache_read: 0.5;
+        readonly context_over_200k: {
+            readonly input: 4;
+            readonly output: 12;
+            readonly cache_read: 1;
+        };
+    };
+    readonly "grok-4.7-fast": {
+        readonly input: 4;
+        readonly output: 12;
+        readonly cache_read: 1;
+        readonly context_over_200k: {
+            readonly input: 6;
+            readonly output: 18;
+            readonly cache_read: 1.5;
+        };
+    };
     readonly "kimi-k2.7-code": {
         readonly input: 0.95;
         readonly output: 4;
@@ -289,6 +315,10 @@ export declare const CURSOR_MODEL_CONTEXTS: {
         readonly maxContext: 300000;
         readonly maxContextForMaxMode: 1000000;
     };
+    readonly "claude-opus-5-5": {
+        readonly maxContext: 300000;
+        readonly maxContextForMaxMode: 1000000;
+    };
     readonly "claude-sonnet-4": {
         readonly maxContext: 200000;
         readonly maxContextForMaxMode: 1000000;
@@ -383,6 +413,10 @@ export declare const CURSOR_MODEL_CONTEXTS: {
     readonly "grok-4.6": {
         readonly maxContext: 256000;
     };
+    readonly "grok-4.7": {
+        readonly maxContext: 256000;
+        readonly maxContextForMaxMode: 500000;
+    };
     readonly "kimi-k2.7-code": {
         readonly maxContext: 262000;
     };
@@ -420,6 +454,9 @@ export declare const CURSOR_MODEL_CAPABILITIES: {
     readonly "claude-opus-5": {
         readonly supportsImages: true;
     };
+    readonly "claude-opus-5-5": {
+        readonly supportsImages: true;
+    };
     readonly "claude-sonnet-4": {
         readonly supportsImages: true;
     };
@@ -498,6 +535,9 @@ export declare const CURSOR_MODEL_CAPABILITIES: {
     readonly "grok-4.6": {
         readonly supportsImages: false;
     };
+    readonly "grok-4.7": {
+        readonly supportsImages: false;
+    };
     readonly "kimi-k2.7-code": {
         readonly supportsImages: true;
     };

package/dist/pricing-data.js

@@ -55,6 +55,12 @@ export const CURSOR_MODEL_COSTS = {
         "cache_read": 0.5,
         "cache_write": 6.25
     },
+    "claude-opus-5-5": {
+        "input": 4,
+        "output": 20,
+        "cache_read": 0.2,
+        "cache_write": 5
+    },
     "claude-sonnet-4": {
         "input": 3,
         "output": 15,
@@ -241,6 +247,26 @@ export const CURSOR_MODEL_COSTS = {
         "output": 12,
         "cache_read": 1
     },
+    "grok-4.7": {
+        "input": 2,
+        "output": 6,
+        "cache_read": 0.5,
+        "context_over_200k": {
+            "input": 4,
+            "output": 12,
+            "cache_read": 1
+        }
+    },
+    "grok-4.7-fast": {
+        "input": 4,
+        "output": 12,
+        "cache_read": 1,
+        "context_over_200k": {
+            "input": 6,
+            "output": 18,
+            "cache_read": 1.5
+        }
+    },
     "kimi-k2.7-code": {
         "input": 0.95,
         "output": 4,
@@ -289,6 +315,10 @@ export const CURSOR_MODEL_CONTEXTS = {
         "maxContext": 300000,
         "maxContextForMaxMode": 1000000
     },
+    "claude-opus-5-5": {
+        "maxContext": 300000,
+        "maxContextForMaxMode": 1000000
+    },
     "claude-sonnet-4": {
         "maxContext": 200000,
         "maxContextForMaxMode": 1000000
@@ -383,6 +413,10 @@ export const CURSOR_MODEL_CONTEXTS = {
     "grok-4.6": {
         "maxContext": 256000
     },
+    "grok-4.7": {
+        "maxContext": 256000,
+        "maxContextForMaxMode": 500000
+    },
     "kimi-k2.7-code": {
         "maxContext": 262000
     },
@@ -420,6 +454,9 @@ export const CURSOR_MODEL_CAPABILITIES = {
     "claude-opus-5": {
         "supportsImages": true
     },
+    "claude-opus-5-5": {
+        "supportsImages": true
+    },
     "claude-sonnet-4": {
         "supportsImages": true
     },
@@ -498,6 +535,9 @@ export const CURSOR_MODEL_CAPABILITIES = {
     "grok-4.6": {
         "supportsImages": false
     },
+    "grok-4.7": {
+        "supportsImages": false
+    },
     "kimi-k2.7-code": {
         "supportsImages": true
     },

package/dist/protocol/ask-question.d.ts

@@ -9,7 +9,7 @@
  * and fall back to prose instead of ever calling the advertised host tool.
  *
  * Every rule below mirrors Cursor CLI, decompiled at
- * `~/Projects/cursor-mock-server/cursor/cli{,-local}`:
+ * `<cursor-cli-checkout>/cursor/cli{,-local}`:
  *
  * - `src/utils/interaction-utils.ts` — `BU` (freeform option id), `Q7` (display
  *   options), `iX` (selection → success), `N$` (rejection + default reason).
@@ -98,19 +98,18 @@ export declare function rejectedResult(reason?: string): AskQuestionResultMessag
 /** `AskQuestionResult{async}` — the immediate reply for `run_async` queries. */
 export declare function asyncResult(): AskQuestionResultMessage;
 /**
- * Pull each question's answer text out of OpenCode's `question` tool output.
+ * Pull each question's answer text out of a host `question` tool output.
  *
- * The tool returns prose, not structured data (`metadata.answers` does not
- * cross the AI SDK boundary):
+ * OpenCode returns prose (`metadata.answers` does not cross the AI SDK
+ * boundary):
  *
  *   User has answered your questions: "<q1>"="<a, b>", "<q2>"="Unanswered". You
  *   can now continue with the user's answers in mind.
  *
- * The provider authored the question strings, so each answer is located by its
- * own `"<question>"="` anchor scanning forward — robust against commas, quotes
- * and `"="` inside question or answer text, and against duplicate questions.
- * Returns undefined for a question whose anchor is absent, which is treated as
- * unanswered rather than guessed at.
+ * The prose is located by its `"<question>"="` anchor — robust
+ * against commas, quotes and `"="` inside question or answer text, and against
+ * duplicate questions. Returns undefined for a question whose anchor is
+ * absent, which is treated as unanswered rather than guessed at.
  */
 export declare function parseAnswerSegments(questions: readonly CursorAskQuestionItem[], output: string): Array<string | undefined>;
 /**

package/dist/protocol/ask-question.js

@@ -9,7 +9,7 @@
  * and fall back to prose instead of ever calling the advertised host tool.
  *
  * Every rule below mirrors Cursor CLI, decompiled at
- * `~/Projects/cursor-mock-server/cursor/cli{,-local}`:
+ * `<cursor-cli-checkout>/cursor/cli{,-local}`:
  *
  * - `src/utils/interaction-utils.ts` — `BU` (freeform option id), `Q7` (display
  *   options), `iX` (selection → success), `N$` (rejection + default reason).
@@ -218,19 +218,18 @@ export function asyncResult() {
     return { async: {} };
 }
 /**
- * Pull each question's answer text out of OpenCode's `question` tool output.
+ * Pull each question's answer text out of a host `question` tool output.
  *
- * The tool returns prose, not structured data (`metadata.answers` does not
- * cross the AI SDK boundary):
+ * OpenCode returns prose (`metadata.answers` does not cross the AI SDK
+ * boundary):
  *
  *   User has answered your questions: "<q1>"="<a, b>", "<q2>"="Unanswered". You
  *   can now continue with the user's answers in mind.
  *
- * The provider authored the question strings, so each answer is located by its
- * own `"<question>"="` anchor scanning forward — robust against commas, quotes
- * and `"="` inside question or answer text, and against duplicate questions.
- * Returns undefined for a question whose anchor is absent, which is treated as
- * unanswered rather than guessed at.
+ * The prose is located by its `"<question>"="` anchor — robust
+ * against commas, quotes and `"="` inside question or answer text, and against
+ * duplicate questions. Returns undefined for a question whose anchor is
+ * absent, which is treated as unanswered rather than guessed at.
  */
 export function parseAnswerSegments(questions, output) {
     const answers = [];

package/dist/protocol/conversation-bind.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { clearCheckpoint } from "./checkpoint.js";
 import { clearConversationBlobs } from "./blob-store.js";
-import { clearFrozenRequestContext, transferFrozenRequestContext, } from "../context/frozen.js";
+import { transferFrozenRequestContext, } from "../context/frozen.js";
 /**
  * OpenCode session key → active Cursor conversation_id.
  *
@@ -11,8 +11,15 @@ import { clearFrozenRequestContext, transferFrozenRequestContext, } from "../con
  * cached conversation against OpenCode's newly compacted prompt.
  */
 const activeBySession = new Map();
+// A compaction id cannot be reconstructed from its host session key. Keep its
+// tiny binding even when the recent-session index soft-evicts that session.
+const remintedBySession = new Map();
 export const MAX_ACTIVE_CONVERSATION_BINDINGS = 256;
 function rememberConversation(sessionKey, conversationId) {
+    if (conversationId === sessionIdToUuid(sessionKey))
+        remintedBySession.delete(sessionKey);
+    else
+        remintedBySession.set(sessionKey, conversationId);
     // Map insertion order is the LRU order. Refresh existing sessions on use.
     activeBySession.delete(sessionKey);
     activeBySession.set(sessionKey, conversationId);
@@ -21,19 +28,21 @@ function rememberConversation(sessionKey, conversationId) {
         if (!oldest)
             break;
         activeBySession.delete(oldest[0]);
-        clearCheckpoint(oldest[1]);
-        clearConversationBlobs(oldest[1]);
-        clearFrozenRequestContext(oldest[1]);
+        // Evict only the lookup pointer. The checkpoint may still be needed by a
+        // held Run, and a returning session can hydrate its durable binding before
+        // resolving another turn. Compaction/reset owns deletion of opaque state.
     }
 }
 export function resetConversationBindingsForTests() {
     activeBySession.clear();
+    remintedBySession.clear();
 }
 export function hasConversationBinding(sessionKey) {
-    return activeBySession.has(sessionKey);
+    return activeBySession.has(sessionKey) || remintedBySession.has(sessionKey);
 }
 export function isActiveConversationBinding(sessionKey, conversationId) {
-    return activeBySession.get(sessionKey) === conversationId;
+    return (activeBySession.get(sessionKey) ?? remintedBySession.get(sessionKey)
+        ?? sessionIdToUuid(sessionKey)) === conversationId;
 }
 /** Restore a validated durable binding before resolving the next Run. */
 export function restoreConversationBinding(sessionKey, conversationId) {
@@ -63,7 +72,7 @@ export function resolveConversationGroupId(sessionKey, conversationId) {
 }
 /** Current Cursor conversation_id for an OpenCode session key, creating the default binding if needed. */
 export function peekConversationId(sessionKey) {
-    let id = activeBySession.get(sessionKey);
+    let id = activeBySession.get(sessionKey) ?? remintedBySession.get(sessionKey);
     if (!id) {
         id = sessionIdToUuid(sessionKey);
     }
@@ -83,7 +92,8 @@ export function bindConversationId(sessionKey, opts) {
         return { conversationId: crypto.randomUUID(), reset: !!opts?.reset };
     }
     if (opts?.reset) {
-        const previousId = activeBySession.get(sessionKey) ?? sessionIdToUuid(sessionKey);
+        const previousId = activeBySession.get(sessionKey) ?? remintedBySession.get(sessionKey)
+            ?? sessionIdToUuid(sessionKey);
         const conversationId = crypto.randomUUID();
         clearCheckpoint(previousId);
         clearConversationBlobs(previousId);

package/dist/protocol/create-plan.d.ts

@@ -54,9 +54,10 @@ export type CursorPlanStageInput = {
  * How a CreatePlan query is satisfied this turn. Keyed only on the advertised
  * catalog and the provider's own plan-mode state — never on host identity.
  *
- * - `stage`   a host plan-stage tool is advertised; the host writes the plan
- *             *and* owns the execution-approval prompt, and its tool result is
- *             the approval outcome (success = approved, error = not approved).
+ * - `stage`   a host plan-stage tool is advertised; the host writes the plan.
+ *             Its tool result is the approval outcome (success = approved,
+ *             error = not approved). The result may name the host's own
+ *             follow-up approval call. This provider does not invent that prompt.
  * - `approve` no such tool, but the host advertises `question`: the provider
  *             writes the plan itself and then asks the same thing with upstream
  *             `PlanExitTool`'s own prompt.
@@ -95,10 +96,8 @@ export declare function createPlanApprovalQuestionInput(planLabel: string): Open
 /**
  * True when the emulated approval prompt came back as an explicit "Yes".
  * An unanswered, dismissed, or failed prompt keeps the model planning rather
- * than silently starting execution.
- *
- * `question` must be the exact prompt that was asked — the host echoes it back
- * verbatim, and it is the anchor the answer is parsed from.
+ * than silently starting execution. OpenCode prose is anchored on the exact
+ * prompt text. Every other result shape fails closed.
  */
 export declare function createPlanApproved(output: string, isError: boolean, question: string): boolean;
 /** Decode a `create_plan_request_query` body, or undefined when unusable. */

package/dist/protocol/create-plan.js

@@ -156,16 +156,15 @@ export function createPlanApprovalQuestionInput(planLabel) {
 /**
  * True when the emulated approval prompt came back as an explicit "Yes".
  * An unanswered, dismissed, or failed prompt keeps the model planning rather
- * than silently starting execution.
- *
- * `question` must be the exact prompt that was asked — the host echoes it back
- * verbatim, and it is the anchor the answer is parsed from.
+ * than silently starting execution. OpenCode prose is anchored on the exact
+ * prompt text. Every other result shape fails closed.
  */
 export function createPlanApproved(output, isError, question) {
     if (isError)
         return false;
     const [segment] = parseAnswerSegments([createPlanApprovalItem(question)], output);
-    return (segment ?? "").trim().toLowerCase() === CREATE_PLAN_APPROVAL_YES.toLowerCase();
+    const answer = (segment ?? "").trim().toLowerCase();
+    return answer === CREATE_PLAN_APPROVAL_YES.toLowerCase();
 }
 function asRecord(value) {
     return value && typeof value === "object" && !Array.isArray(value)

package/dist/protocol/messages.js

@@ -287,7 +287,22 @@ export function createMessageTypes() {
         { id: 3, name: "pattern", type: "string" },
         { id: 4, name: "tool_call_id", type: "string" },
     ]);
-    addType(root, "GetMcpToolsToolCall", [{ id: 1, name: "args", type: "GetMcpToolsArgs" }]);
+    // agent.v1 GetMcpToolsToolCall is args + result. Cursor's agent fills result
+    // locally (GetDynamicTools / GetMcpTools); large catalogs spill through
+    // write_args and put the spill path on GetMcpToolsSuccess.output_file_path.
+    addType(root, "GetMcpToolsSuccess", [
+        { id: 1, name: "content", type: "string" },
+        { id: 2, name: "output_file_path", type: "string" },
+    ]);
+    addType(root, "GetMcpToolsError", [{ id: 1, name: "error", type: "string" }]);
+    addType(root, "GetMcpToolsAgentResult", [
+        { id: 1, name: "success", type: "GetMcpToolsSuccess" },
+        { id: 2, name: "error", type: "GetMcpToolsError" },
+    ], [{ name: "result", fields: ["success", "error"] }]);
+    addType(root, "GetMcpToolsToolCall", [
+        { id: 1, name: "args", type: "GetMcpToolsArgs" },
+        { id: 2, name: "result", type: "GetMcpToolsAgentResult" },
+    ]);
     addType(root, "GenerateImageToolArgs", [
         { id: 1, name: "description", type: "string" },
         { id: 2, name: "file_path", type: "string" },