@playwo/opencode-cursor-oauth 0.0.0-dev.0e8f5d6c8379 → 0.0.0-dev.14c6316643ec

package/dist/logger.d.ts

@@ -2,5 +2,6 @@ import type { PluginInput } from "@opencode-ai/plugin";
 export declare function configurePluginLogger(input: PluginInput): void;
 export declare function errorDetails(error: unknown): Record<string, unknown>;
 export declare function logPluginWarn(message: string, extra?: Record<string, unknown>): void;
+export declare function logPluginInfo(message: string, extra?: Record<string, unknown>): void;
 export declare function logPluginError(message: string, extra?: Record<string, unknown>): void;
 export declare function flushPluginLogs(): Promise<void>;

package/dist/logger.js

@@ -27,6 +27,9 @@ export function errorDetails(error) {
 export function logPluginWarn(message, extra = {}) {
     logPlugin("warn", message, extra);
 }
+export function logPluginInfo(message, extra = {}) {
+    logPlugin("info", message, extra);
+}
 export function logPluginError(message, extra = {}) {
     logPlugin("error", message, extra);
 }

package/dist/proxy/bridge-close-controller.d.ts

@@ -0,0 +1,6 @@
+import type { CursorSession } from "../cursor/bidi-session";
+export declare function createBridgeCloseController(bridge: CursorSession): {
+    noteTurnEnded: () => void;
+    noteCheckpoint: () => void;
+    dispose: () => void;
+};

package/dist/proxy/bridge-close-controller.js

@@ -0,0 +1,37 @@
+import { scheduleBridgeEnd } from "./stream-dispatch";
+const TURN_END_GRACE_MS = 750;
+export function createBridgeCloseController(bridge) {
+    let turnEnded = false;
+    let checkpointSeen = false;
+    let closeTimer;
+    const clearCloseTimer = () => {
+        if (!closeTimer)
+            return;
+        clearTimeout(closeTimer);
+        closeTimer = undefined;
+    };
+    const closeBridge = () => {
+        clearCloseTimer();
+        scheduleBridgeEnd(bridge);
+    };
+    return {
+        noteTurnEnded() {
+            turnEnded = true;
+            if (checkpointSeen) {
+                closeBridge();
+                return;
+            }
+            clearCloseTimer();
+            closeTimer = setTimeout(closeBridge, TURN_END_GRACE_MS);
+        },
+        noteCheckpoint() {
+            checkpointSeen = true;
+            if (turnEnded) {
+                closeBridge();
+            }
+        },
+        dispose() {
+            clearCloseTimer();
+        },
+    };
+}

package/dist/proxy/bridge-non-streaming.js

@@ -5,6 +5,7 @@ import { updateStoredConversationAfterCompletion } from "./conversation-state";
 import { startBridge } from "./bridge-session";
 import { updateConversationCheckpoint, syncStoredBlobStore, } from "./state-sync";
 import { computeUsage, createConnectFrameParser, createThinkingTagFilter, parseConnectEndStream, processServerMessage, scheduleBridgeEnd, } from "./stream-dispatch";
+import { createBridgeCloseController } from "./bridge-close-controller";
 export async function handleNonStreamingResponse(payload, accessToken, modelId, convKey, metadata) {
     const completionId = `chatcmpl-${crypto.randomUUID().replace(/-/g, "").slice(0, 28)}`;
     const created = Math.floor(Date.now() / 1000);
@@ -33,19 +34,18 @@ async function collectFullResponse(payload, accessToken, modelId, convKey, metad
     let endStreamError = null;
     const pendingToolCalls = [];
     const { bridge, heartbeatTimer } = await startBridge(accessToken, payload.requestBytes);
+    const bridgeCloseController = createBridgeCloseController(bridge);
     const state = {
         toolCallIndex: 0,
         pendingExecs: [],
         outputTokens: 0,
         totalTokens: 0,
-        interactionToolArgsText: new Map(),
-        emittedToolCallIds: new Set(),
     };
     const tagFilter = createThinkingTagFilter();
     bridge.onData(createConnectFrameParser((messageBytes) => {
         try {
             const serverMessage = fromBinary(AgentServerMessageSchema, messageBytes);
-            processServerMessage(serverMessage, payload.blobStore, payload.mcpTools, (data) => bridge.write(data), state, (text, isThinking) => {
+            processServerMessage(serverMessage, payload.blobStore, payload.cloudRule, payload.mcpTools, (data) => bridge.write(data), state, (text, isThinking) => {
                 if (isThinking)
                     return;
                 const { content } = tagFilter.process(text);
@@ -60,7 +60,10 @@ async function collectFullResponse(payload, accessToken, modelId, convKey, metad
                     },
                 });
                 scheduleBridgeEnd(bridge);
-            }, (checkpointBytes) => updateConversationCheckpoint(convKey, checkpointBytes), () => scheduleBridgeEnd(bridge), (info) => {
+            }, (checkpointBytes) => {
+                updateConversationCheckpoint(convKey, checkpointBytes);
+                bridgeCloseController.noteCheckpoint();
+            }, () => bridgeCloseController.noteTurnEnded(), (info) => {
                 endStreamError = new Error(`Cursor returned unsupported ${info.category}: ${info.caseName}${info.detail ? ` (${info.detail})` : ""}`);
                 logPluginError("Closing non-streaming Cursor bridge after unsupported message", {
                     modelId,
@@ -97,6 +100,7 @@ async function collectFullResponse(payload, accessToken, modelId, convKey, metad
         scheduleBridgeEnd(bridge);
     }));
     bridge.onClose(() => {
+        bridgeCloseController.dispose();
         clearInterval(heartbeatTimer);
         syncStoredBlobStore(convKey, payload.blobStore);
         const flushed = tagFilter.flush();

package/dist/proxy/bridge-streaming.d.ts

@@ -2,4 +2,4 @@ import { type ToolResultInfo } from "../openai/messages";
 import type { ConversationRequestMetadata } from "./conversation-meta";
 import type { ActiveBridge, CursorRequestPayload } from "./types";
 export declare function handleStreamingResponse(payload: CursorRequestPayload, accessToken: string, modelId: string, bridgeKey: string, convKey: string, metadata: ConversationRequestMetadata): Promise<Response>;
-export declare function handleToolResultResume(active: ActiveBridge, toolResults: ToolResultInfo[], bridgeKey: string, convKey: string): Response;
+export declare function handleToolResultResume(active: ActiveBridge, toolResults: ToolResultInfo[], bridgeKey: string, convKey: string): Promise<Response>;

package/dist/proxy/bridge-streaming.js

@@ -1,17 +1,19 @@
 import { create, fromBinary, toBinary } from "@bufbuild/protobuf";
 import { AgentClientMessageSchema, AgentServerMessageSchema, ExecClientMessageSchema, McpErrorSchema, McpResultSchema, McpSuccessSchema, McpTextContentSchema, McpToolResultContentItemSchema, } from "../proto/agent_pb";
-import { errorDetails, logPluginError, logPluginWarn } from "../logger";
+import { errorDetails, logPluginError, logPluginInfo, logPluginWarn, } from "../logger";
 import { formatToolCallSummary, formatToolResultSummary, } from "../openai/messages";
 import { activeBridges, updateStoredConversationAfterCompletion, } from "./conversation-state";
 import { startBridge } from "./bridge-session";
 import { updateConversationCheckpoint, syncStoredBlobStore, } from "./state-sync";
 import { SSE_HEADERS } from "./sse";
 import { computeUsage, createConnectFrameParser, createThinkingTagFilter, parseConnectEndStream, processServerMessage, scheduleBridgeEnd, } from "./stream-dispatch";
+import { createBridgeCloseController } from "./bridge-close-controller";
 const SSE_KEEPALIVE_INTERVAL_MS = 15_000;
-function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools, modelId, bridgeKey, convKey, metadata) {
+function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, cloudRule, mcpTools, modelId, bridgeKey, convKey, metadata) {
     const completionId = `chatcmpl-${crypto.randomUUID().replace(/-/g, "").slice(0, 28)}`;
     const created = Math.floor(Date.now() / 1000);
     let keepaliveTimer;
+    const bridgeCloseController = createBridgeCloseController(bridge);
     const stopKeepalive = () => {
         if (!keepaliveTimer)
             return;
@@ -27,8 +29,6 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools,
                 pendingExecs: [],
                 outputTokens: 0,
                 totalTokens: 0,
-                interactionToolArgsText: new Map(),
-                emittedToolCallIds: new Set(),
             };
             const tagFilter = createThinkingTagFilter();
             let assistantText = metadata.assistantSeedText ?? "";
@@ -90,7 +90,7 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools,
             const processChunk = createConnectFrameParser((messageBytes) => {
                 try {
                     const serverMessage = fromBinary(AgentServerMessageSchema, messageBytes);
-                    processServerMessage(serverMessage, blobStore, mcpTools, (data) => bridge.write(data), state, (text, isThinking) => {
+                    processServerMessage(serverMessage, blobStore, cloudRule, mcpTools, (data) => bridge.write(data), state, (text, isThinking) => {
                         if (isThinking) {
                             sendSSE(makeChunk({ reasoning_content: text }));
                             return;
@@ -148,6 +148,7 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools,
                             bridge,
                             heartbeatTimer,
                             blobStore,
+                            cloudRule,
                             mcpTools,
                             pendingExecs: state.pendingExecs,
                             modelId,
@@ -159,7 +160,10 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools,
                         sendSSE(makeChunk({}, "tool_calls"));
                         sendDone();
                         closeController();
-                    }, (checkpointBytes) => updateConversationCheckpoint(convKey, checkpointBytes), () => scheduleBridgeEnd(bridge), (info) => {
+                    }, (checkpointBytes) => {
+                        updateConversationCheckpoint(convKey, checkpointBytes);
+                        bridgeCloseController.noteCheckpoint();
+                    }, () => bridgeCloseController.noteTurnEnded(), (info) => {
                         endStreamError = new Error(`Cursor returned unsupported ${info.category}: ${info.caseName}${info.detail ? ` (${info.detail})` : ""}`);
                         logPluginError("Closing Cursor bridge after unsupported message", {
                             modelId,
@@ -212,8 +216,24 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools,
                     stopKeepalive();
                 }
             }, SSE_KEEPALIVE_INTERVAL_MS);
+            logPluginInfo("Opened Cursor streaming bridge", {
+                modelId,
+                bridgeKey,
+                convKey,
+                mcpToolCount: mcpTools.length,
+                hasCloudRule: Boolean(cloudRule),
+            });
             bridge.onData(processChunk);
             bridge.onClose((code) => {
+                logPluginInfo("Cursor streaming bridge closed", {
+                    modelId,
+                    bridgeKey,
+                    convKey,
+                    code,
+                    mcpExecReceived,
+                    hadEndStreamError: Boolean(endStreamError),
+                });
+                bridgeCloseController.dispose();
                 clearInterval(heartbeatTimer);
                 stopKeepalive();
                 syncStoredBlobStore(convKey, blobStore);
@@ -244,6 +264,7 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools,
             });
         },
         cancel(reason) {
+            bridgeCloseController.dispose();
             stopKeepalive();
             clearInterval(heartbeatTimer);
             syncStoredBlobStore(convKey, blobStore);
@@ -263,11 +284,36 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools,
     return new Response(stream, { headers: SSE_HEADERS });
 }
 export async function handleStreamingResponse(payload, accessToken, modelId, bridgeKey, convKey, metadata) {
+    logPluginInfo("Starting Cursor streaming response", {
+        modelId,
+        bridgeKey,
+        convKey,
+        mcpToolCount: payload.mcpTools.length,
+    });
     const { bridge, heartbeatTimer } = await startBridge(accessToken, payload.requestBytes);
-    return createBridgeStreamResponse(bridge, heartbeatTimer, payload.blobStore, payload.mcpTools, modelId, bridgeKey, convKey, metadata);
+    return createBridgeStreamResponse(bridge, heartbeatTimer, payload.blobStore, payload.cloudRule, payload.mcpTools, modelId, bridgeKey, convKey, metadata);
+}
+async function waitForResolvablePendingExecs(active, toolResults, timeoutMs = 2_000) {
+    const pendingToolCallIds = new Set(toolResults.map((result) => result.toolCallId));
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const unresolved = active.pendingExecs.filter((exec) => pendingToolCallIds.has(exec.toolCallId) && exec.execMsgId === 0);
+        if (unresolved.length === 0) {
+            return unresolved;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 25));
+    }
+    const unresolved = active.pendingExecs.filter((exec) => pendingToolCallIds.has(exec.toolCallId) && exec.execMsgId === 0);
+    if (unresolved.length > 0) {
+        logPluginWarn("Cursor exec metadata did not arrive before tool-result resume", {
+            bridgeToolCallIds: unresolved.map((exec) => exec.toolCallId),
+            modelId: active.modelId,
+        });
+    }
+    return unresolved;
 }
-export function handleToolResultResume(active, toolResults, bridgeKey, convKey) {
-    const { bridge, heartbeatTimer, blobStore, mcpTools, pendingExecs, modelId, metadata, } = active;
+export async function handleToolResultResume(active, toolResults, bridgeKey, convKey) {
+    const { bridge, heartbeatTimer, blobStore, cloudRule, mcpTools, pendingExecs, modelId, metadata, } = active;
     const resumeMetadata = {
         ...metadata,
         assistantSeedText: [
@@ -277,6 +323,33 @@ export function handleToolResultResume(active, toolResults, bridgeKey, convKey)
             .filter(Boolean)
             .join("\n\n"),
     };
+    logPluginInfo("Preparing Cursor tool-result resume", {
+        bridgeKey,
+        convKey,
+        modelId,
+        toolResults,
+        pendingExecs,
+    });
+    const unresolved = await waitForResolvablePendingExecs(active, toolResults);
+    logPluginInfo("Resolved pending exec state before Cursor tool-result resume", {
+        bridgeKey,
+        convKey,
+        modelId,
+        toolResults,
+        pendingExecs,
+        unresolvedPendingExecs: unresolved,
+    });
+    if (unresolved.length > 0) {
+        clearInterval(heartbeatTimer);
+        bridge.end();
+        return new Response(JSON.stringify({
+            error: {
+                message: "Cursor requested a tool call but never provided resumable exec metadata. Aborting instead of retrying with synthetic ids.",
+                type: "invalid_request_error",
+                code: "cursor_missing_exec_metadata",
+            },
+        }), { status: 400, headers: { "Content-Type": "application/json" } });
+    }
     for (const exec of pendingExecs) {
         const result = toolResults.find((toolResult) => toolResult.toolCallId === exec.toolCallId);
         const mcpResult = result
@@ -317,7 +390,20 @@ export function handleToolResultResume(active, toolResults, bridgeKey, convKey)
         const clientMessage = create(AgentClientMessageSchema, {
             message: { case: "execClientMessage", value: execClientMessage },
         });
+        logPluginInfo("Sending Cursor tool-result resume message", {
+            bridgeKey,
+            convKey,
+            modelId,
+            toolCallId: exec.toolCallId,
+            toolName: exec.toolName,
+            source: exec.source,
+            execId: exec.execId,
+            execMsgId: exec.execMsgId,
+            cursorCallId: exec.cursorCallId,
+            modelCallId: exec.modelCallId,
+            matchedToolResult: result,
+        });
         bridge.write(toBinary(AgentClientMessageSchema, clientMessage));
     }
-    return createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools, modelId, bridgeKey, convKey, resumeMetadata);
+    return createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, cloudRule, mcpTools, modelId, bridgeKey, convKey, resumeMetadata);
 }

package/dist/proxy/chat-completion.js

@@ -1,4 +1,4 @@
-import { logPluginWarn } from "../logger";
+import { logPluginInfo, logPluginWarn } from "../logger";
 import { buildInitialHandoffPrompt, buildTitleSourceText, buildToolResumePrompt, detectTitleRequest, parseMessages, } from "../openai/messages";
 import { buildMcpToolDefinitions, selectToolsForChoice } from "../openai/tools";
 import { activeBridges, conversationStates, createStoredConversation, deriveBridgeKey, deriveConversationKey, evictStaleConversations, hashString, normalizeAgentKey, resetStoredConversation, } from "./conversation-state";
@@ -10,6 +10,19 @@ export function handleChatCompletion(body, accessToken, context = {}) {
     const { systemPrompt, userText, turns, toolResults, pendingAssistantSummary, completedTurnsFingerprint, } = parsed;
     const modelId = body.model;
     const normalizedAgentKey = normalizeAgentKey(context.agentKey);
+    logPluginInfo("Handling Cursor chat completion request", {
+        modelId,
+        stream: body.stream !== false,
+        messageCount: body.messages.length,
+        toolCount: body.tools?.length ?? 0,
+        toolChoice: body.tool_choice,
+        sessionId: context.sessionId,
+        agentKey: normalizedAgentKey,
+        parsedUserText: userText,
+        parsedToolResults: toolResults,
+        hasPendingAssistantSummary: pendingAssistantSummary.trim().length > 0,
+        turnCount: turns.length,
+    });
     const titleDetection = detectTitleRequest(body);
     const isTitleAgent = titleDetection.matched;
     if (isTitleAgent) {
@@ -38,7 +51,23 @@ export function handleChatCompletion(body, accessToken, context = {}) {
     const bridgeKey = deriveBridgeKey(modelId, body.messages, context.sessionId, context.agentKey);
     const convKey = deriveConversationKey(body.messages, context.sessionId, context.agentKey);
     const activeBridge = activeBridges.get(bridgeKey);
+    logPluginInfo("Resolved Cursor conversation keys", {
+        modelId,
+        bridgeKey,
+        convKey,
+        hasActiveBridge: Boolean(activeBridge),
+        sessionId: context.sessionId,
+        agentKey: normalizedAgentKey,
+    });
     if (activeBridge && toolResults.length > 0) {
+        logPluginInfo("Matched OpenAI tool results to active Cursor bridge", {
+            bridgeKey,
+            convKey,
+            requestedModelId: modelId,
+            activeBridgeModelId: activeBridge.modelId,
+            toolResults,
+            pendingExecs: activeBridge.pendingExecs,
+        });
         activeBridges.delete(bridgeKey);
         if (activeBridge.bridge.alive) {
             if (activeBridge.modelId !== modelId) {
@@ -93,6 +122,16 @@ export function handleChatCompletion(body, accessToken, context = {}) {
             : userText;
     const payload = buildCursorRequest(modelId, systemPrompt, effectiveUserText, replayTurns, stored.conversationId, stored.checkpoint, stored.blobStore);
     payload.mcpTools = mcpTools;
+    logPluginInfo("Built Cursor run request payload", {
+        modelId,
+        bridgeKey,
+        convKey,
+        mcpToolCount: mcpTools.length,
+        conversationId: stored.conversationId,
+        hasCheckpoint: Boolean(stored.checkpoint),
+        replayTurnCount: replayTurns.length,
+        effectiveUserText,
+    });
     if (body.stream === false) {
         return handleNonStreamingResponse(payload, accessToken, modelId, convKey, {
             systemPrompt,

package/dist/proxy/cursor-request.js

@@ -1,13 +1,8 @@
 import { create, fromBinary, toBinary } from "@bufbuild/protobuf";
-import { createHash } from "node:crypto";
-import { AgentClientMessageSchema, AgentRunRequestSchema, ConversationActionSchema, ConversationStateStructureSchema, ConversationStepSchema, AgentConversationTurnStructureSchema, ConversationTurnStructureSchema, AssistantMessageSchema, ModelDetailsSchema, ResumeActionSchema, UserMessageActionSchema, UserMessageSchema, } from "../proto/agent_pb";
+import { AgentClientMessageSchema, AgentRunRequestSchema, AgentConversationTurnStructureSchema, AssistantMessageSchema, ConversationActionSchema, ConversationStateStructureSchema, ConversationTurnStructureSchema, ConversationStepSchema, ModelDetailsSchema, ResumeActionSchema, UserMessageActionSchema, UserMessageSchema, } from "../proto/agent_pb";
 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 +35,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,14 +59,11 @@ export function buildCursorRequest(modelId, systemPrompt, userText, turns, conve
             value: create(UserMessageActionSchema, { userMessage }),
         },
     });
-    return buildRunRequest(modelId, conversationId, conversationState, action, blobStore);
+    return buildRunRequest(modelId, conversationId, conversationState, action, blobStore, cloudRule);
 }
 export function buildCursorResumeRequest(modelId, systemPrompt, conversationId, checkpoint, existingBlobStore) {
     const blobStore = new Map(existingBlobStore ?? []);
-    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);
     const conversationState = fromBinary(ConversationStateStructureSchema, checkpoint);
     const action = create(ConversationActionSchema, {
         action: {
@@ -79,9 +71,9 @@ export function buildCursorResumeRequest(modelId, systemPrompt, conversationId,
             value: create(ResumeActionSchema, {}),
         },
     });
-    return buildRunRequest(modelId, conversationId, conversationState, action, blobStore);
+    return buildRunRequest(modelId, conversationId, conversationState, action, blobStore, cloudRule);
 }
-function buildRunRequest(modelId, conversationId, conversationState, action, blobStore) {
+function buildRunRequest(modelId, conversationId, conversationState, action, blobStore, cloudRule) {
     const modelDetails = create(ModelDetailsSchema, {
         modelId,
         displayModelId: modelId,
@@ -99,6 +91,11 @@ function buildRunRequest(modelId, conversationId, conversationState, action, blo
     return {
         requestBytes: toBinary(AgentClientMessageSchema, clientMessage),
         blobStore,
+        cloudRule,
         mcpTools: [],
     };
 }
+function buildCloudRule(systemPrompt) {
+    const content = systemPrompt.trim();
+    return content || undefined;
+}

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

@@ -39,4 +39,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, onTurnEnded?: () => void, onUnsupportedMessage?: (info: UnsupportedServerMessageInfo) => 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, 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, 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, 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,16 @@ 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, onTurnEnded, onUnsupportedMessage, onUnhandledExec) {
+export function processServerMessage(msg, blobStore, cloudRule, mcpTools, sendFrame, state, onText, onMcpExec, onCheckpoint, onTurnEnded, onUnsupportedMessage, onUnhandledExec) {
     const msgCase = msg.message.case;
     if (msgCase === "interactionUpdate") {
-        handleInteractionUpdate(msg.message.value, state, onText, onMcpExec, onTurnEnded, onUnsupportedMessage);
+        handleInteractionUpdate(msg.message.value, state, onText, onTurnEnded, onUnsupportedMessage);
     }
     else if (msgCase === "kvServerMessage") {
         handleKvMessage(msg.message.value, blobStore, sendFrame);
     }
     else if (msgCase === "execServerMessage") {
-        handleExecMessage(msg.message.value, mcpTools, sendFrame, state, onMcpExec, onUnhandledExec);
+        handleExecMessage(msg.message.value, cloudRule, mcpTools, sendFrame, state, onMcpExec, onUnhandledExec);
     }
     else if (msgCase === "execServerControlMessage") {
         onUnsupportedMessage?.({
@@ -164,8 +164,19 @@ export function processServerMessage(msg, blobStore, mcpTools, sendFrame, state,
         });
     }
 }
-function handleInteractionUpdate(update, state, onText, onMcpExec, onTurnEnded, onUnsupportedMessage) {
+function handleInteractionUpdate(update, state, onText, onTurnEnded, onUnsupportedMessage) {
     const updateCase = update.message?.case;
+    if (updateCase === "partialToolCall" ||
+        updateCase === "toolCallStarted" ||
+        updateCase === "toolCallCompleted" ||
+        updateCase === "turnEnded") {
+        logPluginInfo("Received Cursor interaction update", {
+            updateCase: updateCase ?? "undefined",
+            callId: update.message?.value?.callId,
+            modelCallId: update.message?.value?.modelCallId,
+            toolCase: update.message?.value?.toolCall?.tool?.case,
+        });
+    }
     if (updateCase === "textDelta") {
         const delta = update.message.value.text || "";
         if (delta)
@@ -180,16 +191,19 @@ function handleInteractionUpdate(update, state, onText, onMcpExec, onTurnEnded,
         state.outputTokens += update.message.value.tokens ?? 0;
     }
     else if (updateCase === "partialToolCall") {
-        const partial = update.message.value;
-        if (partial.callId && partial.argsTextDelta) {
-            const existing = state.interactionToolArgsText.get(partial.callId) ?? "";
-            state.interactionToolArgsText.set(partial.callId, `${existing}${partial.argsTextDelta}`);
-        }
+        return;
     }
     else if (updateCase === "toolCallCompleted") {
-        const callId = update.message.value?.callId;
-        if (callId)
-            state.interactionToolArgsText.delete(callId);
+        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?.();
@@ -212,10 +226,8 @@ function handleInteractionUpdate(update, state, onText, onMcpExec, onTurnEnded,
             caseName: updateCase ?? "undefined",
         });
     }
-    // toolCallStarted, partialToolCall, toolCallDelta, and toolCallCompleted are
-    // informational only. Actionable MCP tool execution must come from
-    // execServerMessage.mcpArgs so tool results can be resumed with the correct
-    // exec envelope.
+    // 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;
@@ -342,9 +354,19 @@ function handleKvMessage(kvMsg, blobStore, sendFrame) {
         sendKvResponse(kvMsg, "setBlobResult", create(SetBlobResultSchema, {}), sendFrame);
     }
 }
-function handleExecMessage(execMsg, mcpTools, sendFrame, state, onMcpExec, onUnhandledExec) {
+function handleExecMessage(execMsg, cloudRule, mcpTools, sendFrame, state, onMcpExec, onUnhandledExec) {
     const execCase = execMsg.message.case;
+    logPluginInfo("Received Cursor exec message", {
+        execCase: execCase ?? "undefined",
+        execId: execMsg.execId,
+        execMsgId: execMsg.id,
+    });
     if (execCase === "requestContextArgs") {
+        logPluginInfo("Responding to Cursor requestContextArgs", {
+            execId: execMsg.execId,
+            execMsgId: execMsg.id,
+            mcpToolCount: mcpTools.length,
+        });
         const requestContext = create(RequestContextSchema, {
             rules: [],
             repositoryInfo: [],
@@ -352,6 +374,7 @@ function handleExecMessage(execMsg, mcpTools, sendFrame, state, onMcpExec, onUnh
             gitRepos: [],
             projectLayouts: [],
             mcpInstructions: [],
+            cloudRule,
             fileContents: {},
             customSubagents: [],
         });
@@ -367,18 +390,23 @@ function handleExecMessage(execMsg, mcpTools, sendFrame, state, onMcpExec, onUnh
     if (execCase === "mcpArgs") {
         const mcpArgs = execMsg.message.value;
         const decoded = decodeMcpArgsMap(mcpArgs.args ?? {});
-        const toolCallId = mcpArgs.toolCallId || crypto.randomUUID();
-        if (state.emittedToolCallIds.has(toolCallId)) {
-            return;
-        }
-        state.emittedToolCallIds.add(toolCallId);
-        onMcpExec({
+        const exec = {
             execId: execMsg.execId,
             execMsgId: execMsg.id,
-            toolCallId,
+            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 ---
@@ -386,6 +414,11 @@ function handleExecMessage(execMsg, mcpTools, sendFrame, state, onMcpExec, onUnh
     // 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: {
@@ -400,6 +433,11 @@ function handleExecMessage(execMsg, mcpTools, sendFrame, state, onMcpExec, onUnh
         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: {
@@ -414,6 +452,10 @@ function handleExecMessage(execMsg, mcpTools, sendFrame, state, onMcpExec, onUnh
         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",
@@ -424,6 +466,11 @@ function handleExecMessage(execMsg, mcpTools, sendFrame, state, onMcpExec, onUnh
         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: {
@@ -438,6 +485,11 @@ function handleExecMessage(execMsg, mcpTools, sendFrame, state, onMcpExec, onUnh
         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: {
@@ -452,6 +504,13 @@ function handleExecMessage(execMsg, mcpTools, sendFrame, state, onMcpExec, onUnh
         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: {
@@ -468,6 +527,12 @@ function handleExecMessage(execMsg, mcpTools, sendFrame, state, onMcpExec, onUnh
         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: {
@@ -484,6 +549,10 @@ function handleExecMessage(execMsg, mcpTools, sendFrame, state, onMcpExec, onUnh
         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",
@@ -494,6 +563,11 @@ function handleExecMessage(execMsg, mcpTools, sendFrame, state, onMcpExec, onUnh
         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: {
@@ -508,6 +582,11 @@ function handleExecMessage(execMsg, mcpTools, sendFrame, state, onMcpExec, onUnh
         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;
@@ -521,6 +600,12 @@ function handleExecMessage(execMsg, mcpTools, sendFrame, state, onMcpExec, onUnh
     };
     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/stream-state.d.ts

@@ -4,6 +4,4 @@ export interface StreamState {
     pendingExecs: PendingExec[];
     outputTokens: number;
     totalTokens: number;
-    interactionToolArgsText: Map<string, string>;
-    emittedToolCallIds: Set<string>;
 }

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,12 +15,16 @@ export interface PendingExec {
     toolName: string;
     /** Decoded arguments JSON string for SSE tool_calls emission. */
     decodedArgs: string;
+    source?: "interaction" | "exec";
+    cursorCallId?: string;
+    modelCallId?: string;
 }
 /** 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;

package/package.json

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