cursor-opencode-provider 0.7.6 → 0.8.0

package/dist/protocol/blob-store.js

@@ -9,6 +9,7 @@
  * At a successful TurnEnded it is compacted to the graph reachable from the
  * latest checkpoint, matching Cursor CLI's conversation-export traversal.
  */
+import { errorMessage } from "../debug.js";
 import { collectReachableConversationBlobIds } from "./blob-reachability.js";
 function hex(b) {
     let s = "";
@@ -76,7 +77,7 @@ export function inspectConversationBlobGraph(conversationId, checkpoint) {
         return { count, bytes, complete: true };
     }
     catch (error) {
-        return retainedStats(error instanceof Error ? error.message : String(error));
+        return retainedStats(errorMessage(error));
     }
 }
 /** Copy all durable blobs so a completed turn can be persisted atomically. */
@@ -131,7 +132,7 @@ export function compactConversationBlobs(conversationId, checkpoint) {
         };
     }
     catch (error) {
-        return fallback(error instanceof Error ? error.message : String(error));
+        return fallback(errorMessage(error));
     }
 }
 /** Replace the in-memory blob bucket when restoring a persisted conversation. */

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 { transferFrozenRequestContext, } from "../context/frozen.js";
+import { transferFrozenRequestContext } from "../context/frozen.js";
 /**
  * OpenCode session key → active Cursor conversation_id.
  *

package/dist/protocol/conversation-persistence.d.ts

@@ -11,6 +11,8 @@ export type PersistedConversation = {
     postCompactionRebase: boolean;
     hostAgent?: string;
     systemPromptHash?: string;
+    /** JSON-encoded TurnProvenance (what this provider emitted last). */
+    turnProvenance?: string;
 };
 export type ConversationLoadStatus = "restored" | "missing" | "invalid" | "expired";
 export type PersistedConversationLoad = {

package/dist/protocol/conversation-persistence.js

@@ -47,7 +47,8 @@ function cloneConversation(value) {
  *
  * ConversationCache: schema_version=1, session_key=2, conversation_id=3,
  * updated_at=4, checkpoint=5, blobs=6, request_context=7, tool_catalog=8,
- * post_compaction_rebase=9, host_agent=10, system_prompt_hash=11.
+ * post_compaction_rebase=9, host_agent=10, system_prompt_hash=11,
+ * turn_provenance_json=12.
  * Blob: id=1, data=2. Tool: name=1, description=2,
  * input_schema_json=3, source_name=4.
  *
@@ -176,6 +177,8 @@ function encodeCacheFile(value) {
         writer.uint32(fieldTag(10, 2)).string(value.hostAgent);
     if (value.systemPromptHash)
         writer.uint32(fieldTag(11, 2)).string(value.systemPromptHash);
+    if (value.turnProvenance)
+        writer.uint32(fieldTag(12, 2)).string(value.turnProvenance);
     return { protobufBytes: writer.finish(), requestContextBytes: requestContext.length };
 }
 function decodeProtobuf(data) {
@@ -191,6 +194,7 @@ function decodeProtobuf(data) {
     let postCompactionRebase = false;
     let hostAgent;
     let systemPromptHash;
+    let turnProvenance;
     while (reader.pos < reader.len) {
         const tag = reader.uint32();
         const wireType = tag & 7;
@@ -250,6 +254,11 @@ function decodeProtobuf(data) {
                     throw new Error("invalid system prompt hash");
                 systemPromptHash = reader.string();
                 break;
+            case 12:
+                if (wireType !== 2)
+                    throw new Error("invalid turn provenance");
+                turnProvenance = reader.string();
+                break;
             default:
                 reader.skipType(wireType);
         }
@@ -270,6 +279,7 @@ function decodeProtobuf(data) {
         postCompactionRebase,
         ...(hostAgent ? { hostAgent } : {}),
         ...(systemPromptHash ? { systemPromptHash } : {}),
+        ...(turnProvenance ? { turnProvenance } : {}),
     };
 }
 function decodeCacheFile(compressed, expectedSessionKey) {

package/dist/protocol/conversation-state.d.ts

@@ -7,6 +7,8 @@ export declare function hydrateConversationState(cacheDir: string, sessionKey: s
     hostAgent?: string;
     systemPromptHash?: string;
 } | undefined>;
+/** Restore only turn provenance when its in-memory entry was evicted. */
+export declare function hydrateTurnProvenance(cacheDir: string, sessionKey: string): Promise<void>;
 /** Persist the complete resumable state only after Cursor confirms TurnEnded. */
 export declare function persistConversationState(cacheDir: string, input: {
     sessionKey: string;

package/dist/protocol/conversation-state.js

@@ -3,6 +3,7 @@ import { getFrozenRequestContext, setFrozenRequestContext, } from "../context/fr
 import { hasConversationBinding, isActiveConversationBinding, restoreConversationBinding, } from "./conversation-bind.js";
 import { compactConversationBlobs, restoreConversationBlobs, } from "./blob-store.js";
 import { getCheckpoint, setCheckpoint } from "./checkpoint.js";
+import { getTurnProvenance, parseTurnProvenance, restoreTurnProvenance, serializeTurnProvenance, } from "./turn-provenance.js";
 import { deletePersistedConversation, loadPersistedConversation, persistConversation, } from "./conversation-persistence.js";
 /** Restore one OpenCode session before its conversation binding is resolved. */
 export async function hydrateConversationState(cacheDir, sessionKey) {
@@ -20,6 +21,9 @@ export async function hydrateConversationState(cacheDir, sessionKey) {
         setCheckpoint(persisted.conversationId, persisted.checkpoint);
     restoreConversationBlobs(persisted.conversationId, persisted.blobs);
     setFrozenRequestContext(persisted.conversationId, persisted.requestContext);
+    const provenance = persisted.turnProvenance ? parseTurnProvenance(persisted.turnProvenance) : undefined;
+    if (provenance?.conversationId === persisted.conversationId)
+        restoreTurnProvenance(sessionKey, provenance);
     trace(`conversation persistence: restored sessionKey=${sessionKey} ` +
         `conversationId=${persisted.conversationId} checkpoint=${persisted.checkpoint?.length ?? 0}B ` +
         `blobs=${persisted.blobs.length}`);
@@ -31,6 +35,17 @@ export async function hydrateConversationState(cacheDir, sessionKey) {
         ...(persisted.systemPromptHash ? { systemPromptHash: persisted.systemPromptHash } : {}),
     };
 }
+/** Restore only turn provenance when its in-memory entry was evicted. */
+export async function hydrateTurnProvenance(cacheDir, sessionKey) {
+    if (getTurnProvenance(sessionKey))
+        return;
+    const persisted = (await loadPersistedConversation(cacheDir, sessionKey)).value;
+    if (!persisted?.turnProvenance)
+        return;
+    const provenance = parseTurnProvenance(persisted.turnProvenance);
+    if (provenance?.conversationId === persisted.conversationId)
+        restoreTurnProvenance(sessionKey, provenance);
+}
 /** Persist the complete resumable state only after Cursor confirms TurnEnded. */
 export async function persistConversationState(cacheDir, input) {
     // A newer Run may have reset/superseded this conversation while its final
@@ -44,6 +59,7 @@ export async function persistConversationState(cacheDir, input) {
     const blobCompaction = compactConversationBlobs(input.conversationId, checkpoint);
     const blobs = blobCompaction.blobs;
     const requestContext = getFrozenRequestContext(input.conversationId) ?? input.requestContext;
+    const provenance = getTurnProvenance(input.sessionKey);
     await persistConversation(cacheDir, {
         sessionKey: input.sessionKey,
         conversationId: input.conversationId,
@@ -54,6 +70,9 @@ export async function persistConversationState(cacheDir, input) {
         postCompactionRebase: input.postCompactionRebase,
         hostAgent: input.hostAgent,
         systemPromptHash: input.systemPromptHash,
+        ...(provenance?.conversationId === input.conversationId
+            ? { turnProvenance: serializeTurnProvenance(provenance) }
+            : {}),
     });
     trace(`conversation persistence: saved sessionKey=${input.sessionKey} ` +
         `conversationId=${input.conversationId} checkpoint=${checkpoint?.length ?? 0}B ` +

package/dist/protocol/create-plan.js

@@ -21,6 +21,7 @@ import { pathToFileURL } from "node:url";
 import { hostPlansDir } from "../context/paths.js";
 import { parseAnswerSegments, } from "./ask-question.js";
 import { decodeMessageSparse } from "./messages.js";
+import { errorMessage } from "../debug.js";
 const PLAN_ADJECTIVES = [
     "brave",
     "calm",
@@ -344,7 +345,7 @@ export function writeOpencodePlanFile(args, workspaceRoot, created = Date.now())
         writeFileSync(planPath, markdown, "utf-8");
     }
     catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
+        const message = errorMessage(err);
         return { ok: false, error: `Failed to write plan file: ${message}` };
     }
     return {

package/dist/protocol/messages.js

@@ -1062,9 +1062,27 @@ export function createMessageTypes() {
         { id: 20, name: "is_working_dir_home_dir", type: "bool" },
         { id: 21, name: "process_working_directory", type: "string" },
     ]);
+    // Cursor applies a rule by its type: `global` is the CLI's `alwaysApply: true`
+    // (its AGENTS.md / CLAUDE.md default). An untyped rule is only attachable on
+    // request, so its content never reaches the model on its own.
+    addType(root, "CursorRuleTypeGlobal", []);
+    addType(root, "CursorRuleTypeFileGlobs", [
+        { id: 1, name: "globs", type: "string", repeated: true },
+    ]);
+    addType(root, "CursorRuleTypeAgentFetched", [
+        { id: 1, name: "description", type: "string" },
+    ]);
+    addType(root, "CursorRuleTypeManuallyAttached", []);
+    addType(root, "CursorRuleType", [
+        { id: 1, name: "global", type: "CursorRuleTypeGlobal" },
+        { id: 2, name: "file_globbed", type: "CursorRuleTypeFileGlobs" },
+        { id: 3, name: "agent_fetched", type: "CursorRuleTypeAgentFetched" },
+        { id: 4, name: "manually_attached", type: "CursorRuleTypeManuallyAttached" },
+    ], [{ name: "type", fields: ["global", "file_globbed", "agent_fetched", "manually_attached"] }]);
     addType(root, "CursorRule", [
         { id: 1, name: "full_path", type: "string" },
         { id: 2, name: "content", type: "string" },
+        { id: 3, name: "type", type: "CursorRuleType" },
     ]);
     addType(root, "RepositoryIndexingInfo", [
         { id: 1, name: "relative_workspace_path", type: "string" },
@@ -1151,8 +1169,8 @@ export function createMessageTypes() {
         { 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.
+    // call. OpenCode owns those servers, so answer from the live host catalog
+    // 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" },
@@ -1334,8 +1352,8 @@ export function createMessageTypes() {
         { id: 2, name: "message_id", type: "string" },
         { id: 3, name: "selected_context", type: "SelectedContext" },
     ]);
-    // RequestContext — UserMessageAction #2. Live per-turn tools go here
-    // (AgentRunRequest.mcp_tools #4 is prewarm-only / empty on real turns).
+    // RequestContext — UserMessageAction #2. Slim mcp_meta_tool_options names
+    // the advertised catalog; AgentRunRequest.mcp_tools (#4) is empty on real turns.
     addType(root, "RequestContext", [
         { id: 2, name: "rules", type: "CursorRule", repeated: true },
         { id: 4, name: "env", type: "RequestContextEnv" },

package/dist/protocol/request.d.ts

@@ -1,4 +1,4 @@
-import { type OpencodeToolDef } from "./tools.js";
+import type { OpencodeToolDef } from "./tools.js";
 import type { CursorImageInput } from "../image-input.js";
 export type SeedHistoryMessage = {
     role: "system" | "user" | "assistant";
@@ -11,7 +11,6 @@ export type RunRequestInput = {
     conversationId: string;
     /** Stable parent group; unlike conversationId, this survives compaction/rebase. */
     conversationGroupId?: string;
-    systemPrompt?: string;
     /**
      * Prior chat turns for a seed ConversationStateStructure (no checkpoint).
      * Tool outputs, when required for compaction/recovery, are represented as
@@ -22,7 +21,7 @@ export type RunRequestInput = {
      * Opaque ConversationStateStructure bytes from the last
      * conversation_checkpoint_update for this conversation_id. When set, echoed
      * as AgentRunRequest.conversation_state (CLI parity). When absent, a seed
-     * state with the system prompt (or empty) is built for turn 1.
+     * state carrying only `history` (or empty) is built for turn 1.
      */
     conversationState?: Uint8Array;
     parameterValues?: Array<{
@@ -42,19 +41,22 @@ export type RunRequestInput = {
 /**
  * Seed ConversationStateStructure for the first turn (no checkpoint yet).
  *
- * OpenCode needs a system prompt channel; we put it in root_prompt_messages_json
- * as a JSON chat message. After the first checkpoint arrives we stop inventing
- * state and echo the server's opaque structure instead (CLI behavior).
+ * After the first checkpoint arrives we stop inventing state and echo the
+ * server's opaque structure instead (CLI behavior). Compaction resets and
+ * rebases also use this seed, with `history` carrying OpenCode's prompt turns
+ * so Cursor can continue without the old checkpoint.
  *
- * Compaction resets also use this seed, with `history` carrying OpenCode's
- * compacted prompt turns so Cursor can summarize without the old checkpoint.
+ * No `system` entry is seeded: Cursor does not follow a client-authored
+ * `system` root message, and neither Cursor client writes
+ * `root_prompt_messages_json`. Host system context travels as the
+ * system-instructions rule in RequestContext (`systemInstructionsRule`), so
+ * `system` history entries are dropped here rather than duplicated.
  *
  * We deliberately do NOT use `AgentRunRequest.custom_system_prompt` (#8): that
  * field is the internal `--system-prompt` CLI override and the server rejects
  * it for normal accounts.
  */
 export declare function buildSeedConversationState(input?: {
-    systemPrompt?: string;
     history?: SeedHistoryMessage[];
 }): Uint8Array;
 /**

package/dist/protocol/request.js

@@ -1,14 +1,17 @@
 import { encodeMessage, getMessageTypes } from "./messages.js";
-import { toolsToDescriptors } from "./tools.js";
 /**
  * Seed ConversationStateStructure for the first turn (no checkpoint yet).
  *
- * OpenCode needs a system prompt channel; we put it in root_prompt_messages_json
- * as a JSON chat message. After the first checkpoint arrives we stop inventing
- * state and echo the server's opaque structure instead (CLI behavior).
+ * After the first checkpoint arrives we stop inventing state and echo the
+ * server's opaque structure instead (CLI behavior). Compaction resets and
+ * rebases also use this seed, with `history` carrying OpenCode's prompt turns
+ * so Cursor can continue without the old checkpoint.
  *
- * Compaction resets also use this seed, with `history` carrying OpenCode's
- * compacted prompt turns so Cursor can summarize without the old checkpoint.
+ * No `system` entry is seeded: Cursor does not follow a client-authored
+ * `system` root message, and neither Cursor client writes
+ * `root_prompt_messages_json`. Host system context travels as the
+ * system-instructions rule in RequestContext (`systemInstructionsRule`), so
+ * `system` history entries are dropped here rather than duplicated.
  *
  * We deliberately do NOT use `AgentRunRequest.custom_system_prompt` (#8): that
  * field is the internal `--system-prompt` CLI override and the server rejects
@@ -18,14 +21,8 @@ export function buildSeedConversationState(input) {
     const root = getMessageTypes();
     const type = root.lookupType("ConversationStateStructure");
     const messages = [];
-    if (input?.systemPrompt && input.systemPrompt.length > 0) {
-        messages.push(JSON.stringify({ role: "system", content: input.systemPrompt }));
-    }
     for (const entry of input?.history ?? []) {
-        if (!entry.content)
-            continue;
-        // Avoid duplicating the system prompt when history also carries one.
-        if (entry.role === "system" && input?.systemPrompt)
+        if (!entry.content || entry.role === "system")
             continue;
         messages.push(JSON.stringify({ role: entry.role, content: entry.content }));
     }
@@ -42,11 +39,9 @@ export function buildSeedConversationState(input) {
  */
 export function buildRunRequest(input) {
     const msgId = input.messageId ?? crypto.randomUUID();
-    // Advertise opencode's tools on the LIVE path: UserMessageAction.request_context
-    // (#2). AgentRunRequest.mcp_tools (#4) is prewarm-only / empty on real turns —
-    // putting tools only there is why the model fell back to native Grep/Read.
-    const tools = input.tools ?? [];
-    const mcpTools = input.toolDescriptors ?? (tools.length > 0 ? toolsToDescriptors(tools) : []);
+    // Advertise host tools on UserMessageAction.request_context (#2) via slim
+    // mcp_meta_tool_options. AgentRunRequest.mcp_tools (#4) stays empty on real
+    // turns (CLI prewarm-only). Full defs are session.toolDescriptors + exec #36.
     const requestContext = input.requestContext;
     const userMessage = {
         text: input.text,
@@ -70,10 +65,7 @@ export function buildRunRequest(input) {
         : { user_message_action: userMessageAction };
     const conversationState = input.conversationState && input.conversationState.length > 0
         ? input.conversationState
-        : buildSeedConversationState({
-            systemPrompt: input.systemPrompt,
-            history: input.history,
-        });
+        : buildSeedConversationState({ history: input.history });
     const runRequest = {
         conversation_id: input.conversationId,
         conversation_group_id: input.conversationGroupId ?? input.conversationId,
@@ -88,9 +80,7 @@ export function buildRunRequest(input) {
             parameters: input.parameterValues ?? [],
         },
         conversation_state: conversationState,
-        // Keep #4 populated too (harmless on real turns; useful for prewarm /
-        // older server builds that still read it).
-        mcp_tools: { mcp_tools: mcpTools },
+        mcp_tools: { mcp_tools: [] },
         unknown_flag: 0,
         field_12: 0,
     };

package/dist/protocol/tools.d.ts

@@ -61,7 +61,9 @@ export declare function sanitizeMcpServerId(value: string): string;
 export declare function resolveToolServerIdentity(opencodeName: string, defaultServer?: string, knownMcpServers?: Iterable<string>): ToolServerIdentity;
 /**
  * Convert opencode's per-turn tool list into Cursor `McpToolDefinition`
- * entries for `request_context.tools` (#7) and `AgentRunRequest.mcp_tools`.
+ * entries for session exec remap / bridges. These are not sent on
+ * RequestContext.tools (#7) or AgentRunRequest.mcp_tools (both omitted/empty
+ * on the wire). Exec #36 still uses the same identity fields.
  *
  * Builtins and unknown plugin/custom tools are advertised under the synthetic
  * default server (`opencode`). Tools whose prefixes match configured MCP
@@ -79,12 +81,13 @@ export declare function toolsToDescriptors(tools: OpencodeToolDef[], providerIde
 export declare function buildCustomWebToolAliases(tools: OpencodeToolDef[]): AliasedToolCatalog;
 export declare function resolveCustomWebToolAlias(toolName: string, aliases: ToolAliasRegistry | undefined): string;
 /**
- * Build the nested McpFileSystemOptions / McpMetaToolOptions shape used by
- * requestContext.#23 / #34. One `McpDescriptor` per resolved server (builtins
- * and unknown tools under the synthetic default; configured MCP tools under
- * their upstream server id).
+ * Nested MCP descriptors. Full name/description/schema is for exec #36.
+ * RequestContext `mcp_meta_tool_options` uses `{ namesOnly: true }` (`tool_name`
+ * only). File-system `mcp_descriptors` are omitted on the wire.
  */
-export declare function toolsToMcpDescriptors(tools: OpencodeToolDef[], providerIdentifier?: string, knownMcpServers?: Iterable<string>): Array<Record<string, unknown>>;
+export declare function toolsToMcpDescriptors(tools: OpencodeToolDef[], providerIdentifier?: string, knownMcpServers?: Iterable<string>, options?: {
+    namesOnly?: boolean;
+}): Array<Record<string, unknown>>;
 /**
  * @deprecated Prefer `buildRequestContext` from `../context/build.js`.
  * Kept as a sync tools-only fallback for unit tests that don't need collectors.
@@ -340,11 +343,15 @@ export declare function detectExecVariantField(agentServerPayload: Uint8Array):
  */
 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.
+ * Answer Cursor's exec #36 MCP-state probe from the session's live tool
+ * descriptors: `toolsToDescriptors` output for the advertised catalog (after
+ * web-tool aliasing), refreshed on every `doStream`. These are the same
+ * identities the names-only RequestContext advertises and exec remap uses, so
+ * Cursor's native get_mcp_tools can correlate the later
+ * provider_identifier/tool_name request. OpenCode remains the executor; this
+ * only confirms those tools are available, with full name/description/schema.
  */
-export declare function buildMcpStateResult(execId: number, args: Record<string, unknown>, requestContext: Record<string, unknown>): Uint8Array;
+export declare function buildMcpStateResult(execId: number, args: Record<string, unknown>, toolDescriptors: ReadonlyArray<Record<string, unknown>>): Uint8Array;
 /**
  * Total fallback for Cursor's native MCP-resource exec channel (agent.v1
  * fields #17/#18, tasks/plans/fix-cursor-mcp-resource-exec.md). Under Option B

package/dist/protocol/tools.js

@@ -132,7 +132,9 @@ export function resolveToolServerIdentity(opencodeName, defaultServer = "opencod
 }
 /**
  * Convert opencode's per-turn tool list into Cursor `McpToolDefinition`
- * entries for `request_context.tools` (#7) and `AgentRunRequest.mcp_tools`.
+ * entries for session exec remap / bridges. These are not sent on
+ * RequestContext.tools (#7) or AgentRunRequest.mcp_tools (both omitted/empty
+ * on the wire). Exec #36 still uses the same identity fields.
  *
  * Builtins and unknown plugin/custom tools are advertised under the synthetic
  * default server (`opencode`). Tools whose prefixes match configured MCP
@@ -249,15 +251,15 @@ export function resolveCustomWebToolAlias(toolName, aliases) {
     return toolName;
 }
 /**
- * Build the nested McpFileSystemOptions / McpMetaToolOptions shape used by
- * requestContext.#23 / #34. One `McpDescriptor` per resolved server (builtins
- * and unknown tools under the synthetic default; configured MCP tools under
- * their upstream server id).
+ * Nested MCP descriptors. Full name/description/schema is for exec #36.
+ * RequestContext `mcp_meta_tool_options` uses `{ namesOnly: true }` (`tool_name`
+ * only). File-system `mcp_descriptors` are omitted on the wire.
  */
-export function toolsToMcpDescriptors(tools, providerIdentifier = "opencode", knownMcpServers = []) {
+export function toolsToMcpDescriptors(tools, providerIdentifier = "opencode", knownMcpServers = [], options) {
     if (tools.length === 0)
         return [];
     const byServer = new Map();
+    const namesOnly = options?.namesOnly === true;
     // Walk advertised order: first-seen server, then append tools onto that
     // server. Same-set host reorder is resolved by `resolveTurnToolState`
     // before encode so this walk stays epoch-stable.
@@ -268,11 +270,14 @@ export function toolsToMcpDescriptors(tools, providerIdentifier = "opencode", kn
             list = [];
             byServer.set(id.server, list);
         }
-        list.push({
-            tool_name: t.sourceName ? t.name : id.toolName,
-            description: t.description ?? "",
-            input_schema: encodeJsonAsValue(normalizeInputSchema(t.inputSchema)),
-        });
+        const toolName = t.sourceName ? t.name : id.toolName;
+        list.push(namesOnly
+            ? { tool_name: toolName }
+            : {
+                tool_name: toolName,
+                description: t.description ?? "",
+                input_schema: encodeJsonAsValue(normalizeInputSchema(t.inputSchema)),
+            });
     }
     return [...byServer.keys()].map((server) => ({
         server_name: server,
@@ -285,20 +290,17 @@ export function toolsToMcpDescriptors(tools, providerIdentifier = "opencode", kn
  * Kept as a sync tools-only fallback for unit tests that don't need collectors.
  */
 export function buildLiveRequestContext(tools, providerIdentifier = "opencode", knownMcpServers = []) {
-    const flat = toolsToDescriptors(tools, providerIdentifier, knownMcpServers);
-    const nested = toolsToMcpDescriptors(tools, providerIdentifier, knownMcpServers);
+    const slim = toolsToMcpDescriptors(tools, providerIdentifier, knownMcpServers, { namesOnly: true });
     const cwd = process.cwd();
     const ctx = {
         env: buildEnv(cwd),
-        tools: flat,
         mcp_file_system_options: {
             enabled: true,
             workspace_project_dir: ensureOpencodeProjectDir(cwd),
-            mcp_descriptors: nested,
         },
         mcp_meta_tool_options: {
             enabled: true,
-            mcp_descriptors: nested,
+            ...(slim.length > 0 ? { mcp_descriptors: slim } : {}),
         },
         web_search_enabled: false,
         web_fetch_enabled: false,
@@ -3196,41 +3198,45 @@ 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.
+ * Answer Cursor's exec #36 MCP-state probe from the session's live tool
+ * descriptors: `toolsToDescriptors` output for the advertised catalog (after
+ * web-tool aliasing), refreshed on every `doStream`. These are the same
+ * identities the names-only RequestContext advertises and exec remap uses, so
+ * Cursor's native get_mcp_tools can correlate the later
+ * provider_identifier/tool_name request. OpenCode remains the executor; this
+ * only confirms those tools are available, with full name/description/schema.
  */
-export function buildMcpStateResult(execId, args, requestContext) {
+export function buildMcpStateResult(execId, args, toolDescriptors) {
     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 flatTools = Array.isArray(requestContext.tools)
-        ? requestContext.tools.map(recordValue).filter((tool) => !!tool)
-        : [];
-    const servers = descriptors
-        .filter((descriptor) => {
-        const id = stringValue(descriptor.server_identifier);
-        return requested.size === 0 || (id !== undefined && requested.has(id));
-    })
-        .map((descriptor) => {
-        const serverIdentifier = stringValue(descriptor.server_identifier) ?? stringValue(descriptor.server_name) ?? "";
-        const tools = Array.isArray(descriptor.tools)
-            ? descriptor.tools
-                .map(recordValue)
-                .filter((tool) => !!tool)
-                .map((tool) => mcpStateToolDefinition(serverIdentifier, tool, flatTools))
-            : [];
-        return {
-            server_name: stringValue(descriptor.server_name) ?? serverIdentifier,
-            server_identifier: serverIdentifier,
-            tools,
-        };
-    });
+    // Group in advertised order: first-seen server, then its tools.
+    const byServer = new Map();
+    for (const tool of toolDescriptors) {
+        const server = stringValue(tool.provider_identifier);
+        const toolName = stringValue(tool.tool_name);
+        if (!server || !toolName)
+            continue;
+        if (requested.size > 0 && !requested.has(server))
+            continue;
+        let list = byServer.get(server);
+        if (!list) {
+            list = [];
+            byServer.set(server, list);
+        }
+        list.push({
+            name: stringValue(tool.name) ?? `${server}-${toolName}`,
+            description: stringValue(tool.description) ?? "",
+            input_schema: tool.input_schema,
+            provider_identifier: server,
+            tool_name: toolName,
+        });
+    }
+    const servers = [...byServer].map(([server, tools]) => ({
+        server_name: server,
+        server_identifier: server,
+        tools,
+    }));
     return encodeMessage("AgentClientMessage", {
         exec_client_message: {
             id: execId,
@@ -3238,24 +3244,6 @@ export function buildMcpStateResult(execId, args, requestContext) {
         },
     });
 }
-/**
- * Exec #36 uses McpToolDefinition, not the narrower McpToolDescriptor used by
- * RequestContext's filesystem/meta-tool catalogs. Rehydrate the full identity
- * from RequestContext.tools so Cursor's native get_mcp_tools can correlate the
- * discovered definition with the later provider_identifier/tool_name request.
- */
-function mcpStateToolDefinition(serverIdentifier, descriptor, flatTools) {
-    const toolName = stringValue(descriptor.tool_name) ?? "";
-    const advertised = flatTools.find((tool) => stringValue(tool.provider_identifier) === serverIdentifier
-        && stringValue(tool.tool_name) === toolName);
-    return {
-        name: stringValue(advertised?.name) ?? `${serverIdentifier}-${toolName}`,
-        description: stringValue(advertised?.description) ?? stringValue(descriptor.description) ?? "",
-        input_schema: advertised?.input_schema ?? descriptor.input_schema,
-        provider_identifier: serverIdentifier,
-        tool_name: toolName,
-    };
-}
 /**
  * Total fallback for Cursor's native MCP-resource exec channel (agent.v1
  * fields #17/#18, tasks/plans/fix-cursor-mcp-resource-exec.md). Under Option B
@@ -3285,31 +3273,3 @@ export function buildReadMcpResourceFallback(execId, server, uri) {
         },
     });
 }
-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,
-    }));
-}