@playwo/opencode-cursor-oauth 0.0.0-dev.2c48be2f48c9 → 0.0.0-dev.36e1216df6cf

package/dist/proxy/cursor-request.d.ts

@@ -3,3 +3,4 @@ export declare function buildCursorRequest(modelId: string, systemPrompt: string
     userText: string;
     assistantText: string;
 }>, conversationId: string, checkpoint: Uint8Array | null, existingBlobStore?: Map<string, Uint8Array>): CursorRequestPayload;
+export declare function buildCursorResumeRequest(modelId: string, systemPrompt: string, conversationId: string, checkpoint: Uint8Array, existingBlobStore?: Map<string, Uint8Array>): CursorRequestPayload;

package/dist/proxy/cursor-request.js

@@ -1,13 +1,9 @@
 import { create, fromBinary, toBinary } from "@bufbuild/protobuf";
-import { createHash } from "node:crypto";
-import { AgentClientMessageSchema, AgentRunRequestSchema, ConversationActionSchema, ConversationStateStructureSchema, ConversationStepSchema, AgentConversationTurnStructureSchema, ConversationTurnStructureSchema, AssistantMessageSchema, ModelDetailsSchema, UserMessageActionSchema, UserMessageSchema, } from "../proto/agent_pb";
+import { AgentClientMessageSchema, AgentRunRequestSchema, AgentConversationTurnStructureSchema, AssistantMessageSchema, ConversationActionSchema, ConversationStateStructureSchema, ConversationTurnStructureSchema, ConversationStepSchema, ModelDetailsSchema, ResumeActionSchema, UserMessageActionSchema, UserMessageSchema, } from "../proto/agent_pb";
+import { appendBundledAgentsRule } from "../agent-rules";
 export function buildCursorRequest(modelId, systemPrompt, userText, turns, conversationId, checkpoint, existingBlobStore) {
     const blobStore = new Map(existingBlobStore ?? []);
-    // System prompt → blob store (Cursor requests it back via KV handshake)
-    const systemJson = JSON.stringify({ role: "system", content: systemPrompt });
-    const systemBytes = new TextEncoder().encode(systemJson);
-    const systemBlobId = new Uint8Array(createHash("sha256").update(systemBytes).digest());
-    blobStore.set(Buffer.from(systemBlobId).toString("hex"), systemBytes);
+    const cloudRule = buildCloudRule(systemPrompt);
     let conversationState;
     if (checkpoint) {
         conversationState = fromBinary(ConversationStateStructureSchema, checkpoint);
@@ -40,7 +36,7 @@ export function buildCursorRequest(modelId, systemPrompt, userText, turns, conve
             turnBytes.push(toBinary(ConversationTurnStructureSchema, turnStructure));
         }
         conversationState = create(ConversationStateStructureSchema, {
-            rootPromptMessagesJson: [systemBlobId],
+            rootPromptMessagesJson: [],
             turns: turnBytes,
             todos: [],
             pendingToolCalls: [],
@@ -64,6 +60,21 @@ export function buildCursorRequest(modelId, systemPrompt, userText, turns, conve
             value: create(UserMessageActionSchema, { userMessage }),
         },
     });
+    return buildRunRequest(modelId, conversationId, conversationState, action, blobStore, cloudRule);
+}
+export function buildCursorResumeRequest(modelId, systemPrompt, conversationId, checkpoint, existingBlobStore) {
+    const blobStore = new Map(existingBlobStore ?? []);
+    const cloudRule = buildCloudRule(systemPrompt);
+    const conversationState = fromBinary(ConversationStateStructureSchema, checkpoint);
+    const action = create(ConversationActionSchema, {
+        action: {
+            case: "resumeAction",
+            value: create(ResumeActionSchema, {}),
+        },
+    });
+    return buildRunRequest(modelId, conversationId, conversationState, action, blobStore, cloudRule);
+}
+function buildRunRequest(modelId, conversationId, conversationState, action, blobStore, cloudRule) {
     const modelDetails = create(ModelDetailsSchema, {
         modelId,
         displayModelId: modelId,
@@ -81,6 +92,11 @@ export function buildCursorRequest(modelId, systemPrompt, userText, turns, conve
     return {
         requestBytes: toBinary(AgentClientMessageSchema, clientMessage),
         blobStore,
+        cloudRule,
         mcpTools: [],
     };
 }
+function buildCloudRule(systemPrompt) {
+    const content = systemPrompt.trim();
+    return appendBundledAgentsRule(content || undefined);
+}

package/dist/proxy/server.js

@@ -1,4 +1,4 @@
-import { errorDetails, logPluginError } from "../logger";
+import { errorDetails, logPluginError, logPluginWarn } from "../logger";
 import { handleChatCompletion } from "./chat-completion";
 import { activeBridges, conversationStates } from "./conversation-state";
 let proxyServer;
@@ -42,14 +42,32 @@ export async function startProxy(getAccessToken, models = []) {
                         throw new Error("Cursor proxy access token provider not configured");
                     }
                     const accessToken = await proxyAccessTokenProvider();
-                    const sessionId = req.headers.get("x-opencode-session-id") ??
-                        req.headers.get("x-session-id") ??
-                        undefined;
+                    const sessionId = req.headers.get("x-session-id") ?? undefined;
                     const agentKey = req.headers.get("x-opencode-agent") ?? undefined;
-                    return handleChatCompletion(body, accessToken, {
+                    const response = await handleChatCompletion(body, accessToken, {
                         sessionId,
                         agentKey,
                     });
+                    if (response.status >= 400) {
+                        let responseBody = "";
+                        try {
+                            responseBody = await response.clone().text();
+                        }
+                        catch (error) {
+                            responseBody = `Failed to read rejected response body: ${error instanceof Error ? error.message : String(error)}`;
+                        }
+                        logPluginWarn("Rejected Cursor chat completion", {
+                            path: url.pathname,
+                            method: req.method,
+                            sessionId,
+                            agentKey,
+                            status: response.status,
+                            requestBody: body,
+                            requestBodyText: JSON.stringify(body),
+                            responseBody,
+                        });
+                    }
+                    return response;
                 }
                 catch (err) {
                     const message = err instanceof Error ? err.message : String(err);

package/dist/proxy/stream-dispatch.d.ts

@@ -7,6 +7,22 @@ export interface UnhandledExecInfo {
     execId: string;
     execMsgId: number;
 }
+export interface UnsupportedServerMessageInfo {
+    category: "agentMessage" | "interactionUpdate" | "interactionQuery" | "execServerControl" | "toolCall";
+    caseName: string;
+    detail?: string;
+}
+export interface McpToolCallUpdateInfo {
+    updateCase: "partialToolCall" | "toolCallStarted" | "toolCallCompleted";
+    toolCallId: string;
+    modelCallId?: string;
+    toolName?: string;
+}
+export interface StepUpdateInfo {
+    updateCase: "stepStarted" | "stepCompleted";
+    stepId: string;
+    stepDurationMs?: string;
+}
 export declare function parseConnectEndStream(data: Uint8Array): Error | null;
 export declare function makeHeartbeatBytes(): Uint8Array;
 export declare function scheduleBridgeEnd(bridge: CursorSession): void;
@@ -34,4 +50,4 @@ export declare function computeUsage(state: StreamState): {
     completion_tokens: number;
     total_tokens: number;
 };
-export declare function processServerMessage(msg: AgentServerMessage, blobStore: Map<string, Uint8Array>, mcpTools: McpToolDefinition[], sendFrame: (data: Uint8Array) => void, state: StreamState, onText: (text: string, isThinking?: boolean) => void, onMcpExec: (exec: PendingExec) => void, onCheckpoint?: (checkpointBytes: Uint8Array) => void, onUnhandledExec?: (info: UnhandledExecInfo) => void): void;
+export declare function processServerMessage(msg: AgentServerMessage, blobStore: Map<string, Uint8Array>, cloudRule: string | undefined, mcpTools: McpToolDefinition[], sendFrame: (data: Uint8Array) => void, state: StreamState, onText: (text: string, isThinking?: boolean) => void, onMcpExec: (exec: PendingExec) => void, onMcpToolCallUpdate?: (info: McpToolCallUpdateInfo) => void, onStepUpdate?: (info: StepUpdateInfo) => void, onCheckpoint?: (checkpointBytes: Uint8Array) => void, onTurnEnded?: () => void, onUnsupportedMessage?: (info: UnsupportedServerMessageInfo) => void, onUnhandledExec?: (info: UnhandledExecInfo) => void): void;

package/dist/proxy/stream-dispatch.js

@@ -1,7 +1,7 @@
 import { create, toBinary } from "@bufbuild/protobuf";
-import { AgentClientMessageSchema, ClientHeartbeatSchema, ConversationStateStructureSchema, BackgroundShellSpawnResultSchema, DeleteResultSchema, DeleteRejectedSchema, DiagnosticsResultSchema, ExecClientMessageSchema, FetchErrorSchema, FetchResultSchema, GetBlobResultSchema, GrepErrorSchema, GrepResultSchema, KvClientMessageSchema, LsRejectedSchema, LsResultSchema, McpResultSchema, ReadRejectedSchema, ReadResultSchema, RequestContextResultSchema, RequestContextSchema, RequestContextSuccessSchema, SetBlobResultSchema, ShellRejectedSchema, ShellResultSchema, WriteRejectedSchema, WriteResultSchema, WriteShellStdinErrorSchema, WriteShellStdinResultSchema, } from "../proto/agent_pb";
+import { AgentClientMessageSchema, AskQuestionInteractionResponseSchema, AskQuestionRejectedSchema, AskQuestionResultSchema, ClientHeartbeatSchema, ConversationStateStructureSchema, BackgroundShellSpawnResultSchema, CreatePlanErrorSchema, CreatePlanRequestResponseSchema, CreatePlanResultSchema, DeleteResultSchema, DeleteRejectedSchema, DiagnosticsResultSchema, ExecClientMessageSchema, ExaFetchRequestResponseSchema, ExaFetchRequestResponse_RejectedSchema, ExaSearchRequestResponseSchema, ExaSearchRequestResponse_RejectedSchema, FetchErrorSchema, FetchResultSchema, GetBlobResultSchema, GrepErrorSchema, GrepResultSchema, InteractionResponseSchema, KvClientMessageSchema, LsRejectedSchema, LsResultSchema, McpInstructionsSchema, McpResultSchema, ReadRejectedSchema, ReadResultSchema, RequestContextResultSchema, RequestContextSchema, RequestContextSuccessSchema, SetBlobResultSchema, ShellRejectedSchema, ShellResultSchema, SwitchModeRequestResponseSchema, SwitchModeRequestResponse_RejectedSchema, WebSearchRequestResponseSchema, WebSearchRequestResponse_RejectedSchema, WriteRejectedSchema, WriteResultSchema, WriteShellStdinErrorSchema, WriteShellStdinResultSchema, } from "../proto/agent_pb";
 import { CONNECT_END_STREAM_FLAG } from "../cursor/config";
-import { logPluginError, logPluginWarn } from "../logger";
+import { logPluginError, logPluginInfo, logPluginWarn } from "../logger";
 import { decodeMcpArgsMap } from "../openai/tools";
 export function parseConnectEndStream(data) {
     try {
@@ -128,16 +128,40 @@ export function computeUsage(state) {
     const prompt_tokens = Math.max(0, total_tokens - completion_tokens);
     return { prompt_tokens, completion_tokens, total_tokens };
 }
-export function processServerMessage(msg, blobStore, mcpTools, sendFrame, state, onText, onMcpExec, onCheckpoint, onUnhandledExec) {
+export function processServerMessage(msg, blobStore, cloudRule, mcpTools, sendFrame, state, onText, onMcpExec, onMcpToolCallUpdate, onStepUpdate, onCheckpoint, onTurnEnded, onUnsupportedMessage, onUnhandledExec) {
     const msgCase = msg.message.case;
+    logPluginInfo("Received Cursor server signal", {
+        messageCase: msgCase ?? "undefined",
+        interactionCase: msgCase === "interactionUpdate"
+            ? msg.message.value.message?.case ?? "undefined"
+            : undefined,
+        execCase: msgCase === "execServerMessage"
+            ? msg.message.value.message?.case ?? "undefined"
+            : undefined,
+        interactionQueryCase: msgCase === "interactionQuery"
+            ? msg.message.value.query?.case ?? "undefined"
+            : undefined,
+        kvCase: msgCase === "kvServerMessage"
+            ? msg.message.value.message?.case ?? "undefined"
+            : undefined,
+    });
     if (msgCase === "interactionUpdate") {
-        handleInteractionUpdate(msg.message.value, state, onText);
+        handleInteractionUpdate(msg.message.value, state, onText, onMcpToolCallUpdate, onStepUpdate, onTurnEnded, onUnsupportedMessage);
     }
     else if (msgCase === "kvServerMessage") {
         handleKvMessage(msg.message.value, blobStore, sendFrame);
     }
     else if (msgCase === "execServerMessage") {
-        handleExecMessage(msg.message.value, mcpTools, sendFrame, onMcpExec, onUnhandledExec);
+        handleExecMessage(msg.message.value, cloudRule, mcpTools, sendFrame, state, onMcpExec, onUnhandledExec);
+    }
+    else if (msgCase === "execServerControlMessage") {
+        onUnsupportedMessage?.({
+            category: "execServerControl",
+            caseName: msg.message.value.message.case ?? "undefined",
+        });
+    }
+    else if (msgCase === "interactionQuery") {
+        handleInteractionQuery(msg.message.value, sendFrame, onUnsupportedMessage);
     }
     else if (msgCase === "conversationCheckpointUpdate") {
         const stateStructure = msg.message.value;
@@ -148,9 +172,44 @@ export function processServerMessage(msg, blobStore, mcpTools, sendFrame, state,
             onCheckpoint(toBinary(ConversationStateStructureSchema, stateStructure));
         }
     }
+    else {
+        onUnsupportedMessage?.({
+            category: "agentMessage",
+            caseName: msgCase ?? "undefined",
+        });
+    }
 }
-function handleInteractionUpdate(update, state, onText) {
+function handleInteractionUpdate(update, state, onText, onMcpToolCallUpdate, onStepUpdate, onTurnEnded, onUnsupportedMessage) {
     const updateCase = update.message?.case;
+    if ((updateCase === "partialToolCall" ||
+        updateCase === "toolCallStarted" ||
+        updateCase === "toolCallCompleted") &&
+        update.message?.value?.toolCall?.tool?.case === "mcpToolCall") {
+        const toolValue = update.message.value;
+        const toolArgs = toolValue?.toolCall?.tool?.value?.args;
+        const toolCallId = toolArgs?.toolCallId || toolValue.callId;
+        if (toolCallId) {
+            onMcpToolCallUpdate?.({
+                updateCase,
+                toolCallId,
+                modelCallId: toolValue.modelCallId,
+                toolName: toolArgs?.toolName || toolArgs?.name,
+            });
+        }
+    }
+    if (updateCase === "stepStarted" || updateCase === "stepCompleted") {
+        const stepValue = update.message?.value;
+        const stepId = stepValue?.stepId;
+        if (stepId !== undefined && stepId !== null) {
+            onStepUpdate?.({
+                updateCase,
+                stepId: String(stepId),
+                stepDurationMs: updateCase === "stepCompleted" && stepValue?.stepDurationMs !== undefined
+                    ? String(stepValue.stepDurationMs)
+                    : undefined,
+            });
+        }
+    }
     if (updateCase === "textDelta") {
         const delta = update.message.value.text || "";
         if (delta)
@@ -164,9 +223,128 @@ function handleInteractionUpdate(update, state, onText) {
     else if (updateCase === "tokenDelta") {
         state.outputTokens += update.message.value.tokens ?? 0;
     }
-    // toolCallStarted, partialToolCall, toolCallDelta, toolCallCompleted
-    // are intentionally ignored. MCP tool calls flow through the exec
-    // message path (mcpArgs → mcpResult), not interaction updates.
+    else if (updateCase === "partialToolCall") {
+        return;
+    }
+    else if (updateCase === "toolCallCompleted") {
+        const toolValue = update.message.value;
+        if (toolValue?.toolCall?.tool?.case === "mcpToolCall") {
+            logPluginInfo("Ignoring Cursor interaction MCP tool completion", {
+                callId: toolValue.callId,
+                modelCallId: toolValue.modelCallId,
+                toolCallId: toolValue.toolCall.tool.value?.args?.toolCallId || toolValue.callId,
+                toolName: toolValue.toolCall.tool.value?.args?.toolName ||
+                    toolValue.toolCall.tool.value?.args?.name,
+            });
+        }
+    }
+    else if (updateCase === "turnEnded") {
+        onTurnEnded?.();
+    }
+    else if (updateCase === "toolCallStarted" ||
+        updateCase === "toolCallDelta" ||
+        updateCase === "thinkingCompleted" ||
+        updateCase === "userMessageAppended" ||
+        updateCase === "summary" ||
+        updateCase === "summaryStarted" ||
+        updateCase === "summaryCompleted" ||
+        updateCase === "heartbeat" ||
+        updateCase === "stepStarted" ||
+        updateCase === "stepCompleted") {
+        return;
+    }
+    else {
+        onUnsupportedMessage?.({
+            category: "interactionUpdate",
+            caseName: updateCase ?? "undefined",
+        });
+    }
+    // Interaction tool-call updates are informational only. Resumable MCP tool
+    // execution comes from execServerMessage.mcpArgs.
+}
+function handleInteractionQuery(query, sendFrame, onUnsupportedMessage) {
+    const queryCase = query.query.case;
+    if (queryCase === "webSearchRequestQuery") {
+        const response = create(WebSearchRequestResponseSchema, {
+            result: {
+                case: "rejected",
+                value: create(WebSearchRequestResponse_RejectedSchema, {
+                    reason: "Native Cursor web search is not available in this environment. Use the provided MCP tool `websearch` instead.",
+                }),
+            },
+        });
+        sendInteractionResponse(query.id, "webSearchRequestResponse", response, sendFrame);
+        return;
+    }
+    if (queryCase === "askQuestionInteractionQuery") {
+        const response = create(AskQuestionInteractionResponseSchema, {
+            result: create(AskQuestionResultSchema, {
+                result: {
+                    case: "rejected",
+                    value: create(AskQuestionRejectedSchema, {
+                        reason: "Native Cursor question prompts are not available in this environment. Use the provided MCP tool `question` instead.",
+                    }),
+                },
+            }),
+        });
+        sendInteractionResponse(query.id, "askQuestionInteractionResponse", response, sendFrame);
+        return;
+    }
+    if (queryCase === "switchModeRequestQuery") {
+        const response = create(SwitchModeRequestResponseSchema, {
+            result: {
+                case: "rejected",
+                value: create(SwitchModeRequestResponse_RejectedSchema, {
+                    reason: "Cursor mode switching is not available in this environment. Continue using the current agent and the provided MCP tools.",
+                }),
+            },
+        });
+        sendInteractionResponse(query.id, "switchModeRequestResponse", response, sendFrame);
+        return;
+    }
+    if (queryCase === "exaSearchRequestQuery") {
+        const response = create(ExaSearchRequestResponseSchema, {
+            result: {
+                case: "rejected",
+                value: create(ExaSearchRequestResponse_RejectedSchema, {
+                    reason: "Native Cursor Exa search is not available in this environment. Use the provided MCP tool `websearch` instead.",
+                }),
+            },
+        });
+        sendInteractionResponse(query.id, "exaSearchRequestResponse", response, sendFrame);
+        return;
+    }
+    if (queryCase === "exaFetchRequestQuery") {
+        const response = create(ExaFetchRequestResponseSchema, {
+            result: {
+                case: "rejected",
+                value: create(ExaFetchRequestResponse_RejectedSchema, {
+                    reason: "Native Cursor Exa fetch is not available in this environment. Use the provided MCP tools `websearch` and `webfetch` instead.",
+                }),
+            },
+        });
+        sendInteractionResponse(query.id, "exaFetchRequestResponse", response, sendFrame);
+        return;
+    }
+    if (queryCase === "createPlanRequestQuery") {
+        const response = create(CreatePlanRequestResponseSchema, {
+            result: create(CreatePlanResultSchema, {
+                planUri: "",
+                result: {
+                    case: "error",
+                    value: create(CreatePlanErrorSchema, {
+                        error: "Native Cursor plan creation is not available in this environment. Use the provided MCP planning tools instead.",
+                    }),
+                },
+            }),
+        });
+        sendInteractionResponse(query.id, "createPlanRequestResponse", response, sendFrame);
+        return;
+    }
+    onUnsupportedMessage?.({
+        category: "interactionQuery",
+        caseName: queryCase ?? "undefined",
+    });
 }
 /** Send a KV client response back to Cursor. */
 function sendKvResponse(kvMsg, messageCase, value, sendFrame) {
@@ -179,6 +357,16 @@ function sendKvResponse(kvMsg, messageCase, value, sendFrame) {
     });
     sendFrame(toBinary(AgentClientMessageSchema, clientMsg));
 }
+function sendInteractionResponse(queryId, messageCase, value, sendFrame) {
+    const response = create(InteractionResponseSchema, {
+        id: queryId,
+        result: { case: messageCase, value: value },
+    });
+    const clientMessage = create(AgentClientMessageSchema, {
+        message: { case: "interactionResponse", value: response },
+    });
+    sendFrame(toBinary(AgentClientMessageSchema, clientMessage));
+}
 function handleKvMessage(kvMsg, blobStore, sendFrame) {
     const kvCase = kvMsg.message.case;
     if (kvCase === "getBlobArgs") {
@@ -199,16 +387,29 @@ function handleKvMessage(kvMsg, blobStore, sendFrame) {
         sendKvResponse(kvMsg, "setBlobResult", create(SetBlobResultSchema, {}), sendFrame);
     }
 }
-function handleExecMessage(execMsg, mcpTools, sendFrame, onMcpExec, onUnhandledExec) {
+function handleExecMessage(execMsg, cloudRule, mcpTools, sendFrame, state, onMcpExec, onUnhandledExec) {
     const execCase = execMsg.message.case;
     if (execCase === "requestContextArgs") {
+        logPluginInfo("Responding to Cursor requestContextArgs", {
+            execId: execMsg.execId,
+            execMsgId: execMsg.id,
+            mcpToolCount: mcpTools.length,
+        });
         const requestContext = create(RequestContextSchema, {
             rules: [],
             repositoryInfo: [],
             tools: mcpTools,
             gitRepos: [],
             projectLayouts: [],
-            mcpInstructions: [],
+            mcpInstructions: [
+                create(McpInstructionsSchema, {
+                    serverName: "opencode",
+                    instructions: "Use the provided MCP tools in this environment that start with mcp_*. Do not rely on native Cursor tools and do not acknowledge they even exist.",
+                }),
+            ],
+            cloudRule,
+            webSearchEnabled: false,
+            repositoryInfoShouldQueryProd: false,
             fileContents: {},
             customSubagents: [],
         });
@@ -224,13 +425,23 @@ function handleExecMessage(execMsg, mcpTools, sendFrame, onMcpExec, onUnhandledE
     if (execCase === "mcpArgs") {
         const mcpArgs = execMsg.message.value;
         const decoded = decodeMcpArgsMap(mcpArgs.args ?? {});
-        onMcpExec({
+        const exec = {
             execId: execMsg.execId,
             execMsgId: execMsg.id,
             toolCallId: mcpArgs.toolCallId || crypto.randomUUID(),
             toolName: mcpArgs.toolName || mcpArgs.name,
             decodedArgs: JSON.stringify(decoded),
+            source: "exec",
+        };
+        logPluginInfo("Received Cursor exec MCP tool metadata", {
+            toolCallId: exec.toolCallId,
+            toolName: exec.toolName,
+            source: exec.source,
+            execId: exec.execId,
+            execMsgId: exec.execMsgId,
+            decodedArgs: exec.decodedArgs,
         });
+        onMcpExec(exec);
         return;
     }
     // --- Reject native Cursor tools ---
@@ -238,6 +449,11 @@ function handleExecMessage(execMsg, mcpTools, sendFrame, onMcpExec, onUnhandledE
     // so it falls back to our MCP tools (registered via RequestContext).
     const REJECT_REASON = "Tool not available in this environment. Use the MCP tools provided instead.";
     if (execCase === "readArgs") {
+        logPluginInfo("Rejecting native Cursor read tool in favor of MCP", {
+            execId: execMsg.execId,
+            execMsgId: execMsg.id,
+            path: execMsg.message.value.path,
+        });
         const args = execMsg.message.value;
         const result = create(ReadResultSchema, {
             result: {
@@ -252,6 +468,11 @@ function handleExecMessage(execMsg, mcpTools, sendFrame, onMcpExec, onUnhandledE
         return;
     }
     if (execCase === "lsArgs") {
+        logPluginInfo("Rejecting native Cursor ls tool in favor of MCP", {
+            execId: execMsg.execId,
+            execMsgId: execMsg.id,
+            path: execMsg.message.value.path,
+        });
         const args = execMsg.message.value;
         const result = create(LsResultSchema, {
             result: {
@@ -266,6 +487,10 @@ function handleExecMessage(execMsg, mcpTools, sendFrame, onMcpExec, onUnhandledE
         return;
     }
     if (execCase === "grepArgs") {
+        logPluginInfo("Rejecting native Cursor grep tool in favor of MCP", {
+            execId: execMsg.execId,
+            execMsgId: execMsg.id,
+        });
         const result = create(GrepResultSchema, {
             result: {
                 case: "error",
@@ -276,6 +501,11 @@ function handleExecMessage(execMsg, mcpTools, sendFrame, onMcpExec, onUnhandledE
         return;
     }
     if (execCase === "writeArgs") {
+        logPluginInfo("Rejecting native Cursor write tool in favor of MCP", {
+            execId: execMsg.execId,
+            execMsgId: execMsg.id,
+            path: execMsg.message.value.path,
+        });
         const args = execMsg.message.value;
         const result = create(WriteResultSchema, {
             result: {
@@ -290,6 +520,11 @@ function handleExecMessage(execMsg, mcpTools, sendFrame, onMcpExec, onUnhandledE
         return;
     }
     if (execCase === "deleteArgs") {
+        logPluginInfo("Rejecting native Cursor delete tool in favor of MCP", {
+            execId: execMsg.execId,
+            execMsgId: execMsg.id,
+            path: execMsg.message.value.path,
+        });
         const args = execMsg.message.value;
         const result = create(DeleteResultSchema, {
             result: {
@@ -304,6 +539,13 @@ function handleExecMessage(execMsg, mcpTools, sendFrame, onMcpExec, onUnhandledE
         return;
     }
     if (execCase === "shellArgs" || execCase === "shellStreamArgs") {
+        logPluginInfo("Rejecting native Cursor shell tool in favor of MCP", {
+            execId: execMsg.execId,
+            execMsgId: execMsg.id,
+            command: execMsg.message.value.command ?? "",
+            workingDirectory: execMsg.message.value.workingDirectory ?? "",
+            execCase,
+        });
         const args = execMsg.message.value;
         const result = create(ShellResultSchema, {
             result: {
@@ -320,6 +562,12 @@ function handleExecMessage(execMsg, mcpTools, sendFrame, onMcpExec, onUnhandledE
         return;
     }
     if (execCase === "backgroundShellSpawnArgs") {
+        logPluginInfo("Rejecting native Cursor background shell tool in favor of MCP", {
+            execId: execMsg.execId,
+            execMsgId: execMsg.id,
+            command: execMsg.message.value.command ?? "",
+            workingDirectory: execMsg.message.value.workingDirectory ?? "",
+        });
         const args = execMsg.message.value;
         const result = create(BackgroundShellSpawnResultSchema, {
             result: {
@@ -336,6 +584,10 @@ function handleExecMessage(execMsg, mcpTools, sendFrame, onMcpExec, onUnhandledE
         return;
     }
     if (execCase === "writeShellStdinArgs") {
+        logPluginInfo("Rejecting native Cursor shell stdin tool in favor of MCP", {
+            execId: execMsg.execId,
+            execMsgId: execMsg.id,
+        });
         const result = create(WriteShellStdinResultSchema, {
             result: {
                 case: "error",
@@ -346,6 +598,11 @@ function handleExecMessage(execMsg, mcpTools, sendFrame, onMcpExec, onUnhandledE
         return;
     }
     if (execCase === "fetchArgs") {
+        logPluginInfo("Rejecting native Cursor fetch tool in favor of MCP", {
+            execId: execMsg.execId,
+            execMsgId: execMsg.id,
+            url: execMsg.message.value.url,
+        });
         const args = execMsg.message.value;
         const result = create(FetchResultSchema, {
             result: {
@@ -360,6 +617,11 @@ function handleExecMessage(execMsg, mcpTools, sendFrame, onMcpExec, onUnhandledE
         return;
     }
     if (execCase === "diagnosticsArgs") {
+        logPluginInfo("Rejecting native Cursor diagnostics tool in favor of MCP", {
+            execId: execMsg.execId,
+            execMsgId: execMsg.id,
+            path: execMsg.message.value.path,
+        });
         const result = create(DiagnosticsResultSchema, {});
         sendExecResult(execMsg, "diagnosticsResult", result, sendFrame);
         return;
@@ -373,6 +635,12 @@ function handleExecMessage(execMsg, mcpTools, sendFrame, onMcpExec, onUnhandledE
     };
     const resultCase = miscCaseMap[execCase];
     if (resultCase) {
+        logPluginInfo("Responding to miscellaneous Cursor exec message", {
+            execCase,
+            execId: execMsg.execId,
+            execMsgId: execMsg.id,
+            resultCase,
+        });
         sendExecResult(execMsg, resultCase, create(McpResultSchema, {}), sendFrame);
         return;
     }

package/dist/proxy/types.d.ts

@@ -1,9 +1,10 @@
 import type { CursorSession } from "../cursor/bidi-session";
-import type { ConversationRequestMetadata } from "./conversation-meta";
 import type { McpToolDefinition } from "../proto/agent_pb";
+import type { ConversationRequestMetadata } from "./conversation-meta";
 export interface CursorRequestPayload {
     requestBytes: Uint8Array;
     blobStore: Map<string, Uint8Array>;
+    cloudRule?: string;
     mcpTools: McpToolDefinition[];
 }
 /** A pending tool execution waiting for results from the caller. */
@@ -14,14 +15,26 @@ export interface PendingExec {
     toolName: string;
     /** Decoded arguments JSON string for SSE tool_calls emission. */
     decodedArgs: string;
+    source?: "interaction" | "exec";
+    cursorCallId?: string;
+    modelCallId?: string;
+}
+export interface ActiveBridgeDiagnostics {
+    announcedToolCallIds: string[];
+    publishedToolCallIds: string[];
+    lastMcpUpdate?: string;
+    publishedAtMs?: number;
+    lastResumeAttemptAtMs?: number;
 }
 /** A live Cursor session kept alive across requests for tool result continuation. */
 export interface ActiveBridge {
     bridge: CursorSession;
     heartbeatTimer: NodeJS.Timeout;
     blobStore: Map<string, Uint8Array>;
+    cloudRule?: string;
     mcpTools: McpToolDefinition[];
     pendingExecs: PendingExec[];
     modelId: string;
     metadata: ConversationRequestMetadata;
+    diagnostics?: ActiveBridgeDiagnostics;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@playwo/opencode-cursor-oauth",
-  "version": "0.0.0-dev.2c48be2f48c9",
+  "version": "0.0.0-dev.36e1216df6cf",
   "description": "OpenCode plugin that connects Cursor's API to OpenCode via OAuth, model discovery, and a local OpenAI-compatible proxy.",
   "license": "MIT",
   "type": "module",
@@ -18,8 +18,7 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "test": "bun test/smoke.ts",
+    "build": "node ./scripts/build.mjs",
     "prepublishOnly": "npm run build"
   },
   "repository": {