@playwo/opencode-cursor-oauth 0.0.0-dev.6338d5591e37 → 0.0.0-dev.67ecd4697583

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-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,6 +1,6 @@
 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";
@@ -103,6 +103,13 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools,
                             sendSSE(makeChunk({ content }));
                         }
                     }, (exec) => {
+                        const existingIndex = state.pendingExecs.findIndex((candidate) => candidate.toolCallId === exec.toolCallId);
+                        if (existingIndex >= 0) {
+                            state.pendingExecs[existingIndex] = exec;
+                        }
+                        else {
+                            state.pendingExecs.push(exec);
+                        }
                         mcpExecReceived = true;
                         const flushed = tagFilter.flush();
                         if (flushed.reasoning)
@@ -259,7 +266,26 @@ export async function handleStreamingResponse(payload, accessToken, modelId, bri
     const { bridge, heartbeatTimer } = await startBridge(accessToken, payload.requestBytes);
     return createBridgeStreamResponse(bridge, heartbeatTimer, payload.blobStore, payload.mcpTools, modelId, bridgeKey, convKey, metadata);
 }
-export function handleToolResultResume(active, toolResults, bridgeKey, convKey) {
+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 async function handleToolResultResume(active, toolResults, bridgeKey, convKey) {
     const { bridge, heartbeatTimer, blobStore, mcpTools, pendingExecs, modelId, metadata, } = active;
     const resumeMetadata = {
         ...metadata,
@@ -270,6 +296,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: 409, headers: { "Content-Type": "application/json" } });
+    }
     for (const exec of pendingExecs) {
         const result = toolResults.find((toolResult) => toolResult.toolCallId === exec.toolCallId);
         const mcpResult = result
@@ -310,6 +363,19 @@ 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);

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";
@@ -39,6 +39,14 @@ export function handleChatCompletion(body, accessToken, context = {}) {
     const convKey = deriveConversationKey(body.messages, context.sessionId, context.agentKey);
     const activeBridge = activeBridges.get(bridgeKey);
     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) {

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,12 +128,8 @@ export function computeUsage(state) {
     const prompt_tokens = Math.max(0, total_tokens - completion_tokens);
     return { prompt_tokens, completion_tokens, total_tokens };
 }
-function getPendingExecKey(exec) {
-    return exec.toolCallId || `${exec.toolName}:${exec.decodedArgs}`;
-}
 function replacePendingExec(state, exec) {
-    const execKey = getPendingExecKey(exec);
-    const existingIndex = state.pendingExecs.findIndex((candidate) => getPendingExecKey(candidate) === execKey);
+    const existingIndex = state.pendingExecs.findIndex((candidate) => candidate.toolCallId === exec.toolCallId);
     if (existingIndex >= 0) {
         state.pendingExecs[existingIndex] = exec;
         return;
@@ -159,18 +155,54 @@ function mergePendingExec(existing, incoming) {
         decodedArgs: hasUsableDecodedArgs(incoming.decodedArgs)
             ? incoming.decodedArgs
             : existing.decodedArgs,
+        source: incomingHasExecMetadata ? incoming.source : existing.source ?? incoming.source,
+        cursorCallId: existing.cursorCallId || incoming.cursorCallId,
+        modelCallId: existing.modelCallId || incoming.modelCallId,
     };
 }
 function emitPendingExec(exec, state, onMcpExec) {
-    const execKey = getPendingExecKey(exec);
-    const existing = state.pendingExecs.find((candidate) => getPendingExecKey(candidate) === execKey);
+    const existing = state.pendingExecs.find((candidate) => candidate.toolCallId === exec.toolCallId);
     const nextExec = existing ? mergePendingExec(existing, exec) : exec;
-    if (state.emittedToolCallIds.has(execKey)) {
+    const hadActionableMetadata = (existing?.execMsgId ?? 0) !== 0;
+    const hasActionableMetadata = nextExec.execMsgId !== 0;
+    if (state.emittedToolCallIds.has(nextExec.toolCallId)) {
         replacePendingExec(state, nextExec);
+        if (!hadActionableMetadata && hasActionableMetadata) {
+            logPluginInfo("Cursor MCP tool call metadata upgraded", {
+                toolCallId: nextExec.toolCallId,
+                toolName: nextExec.toolName,
+                source: nextExec.source,
+                execId: nextExec.execId,
+                execMsgId: nextExec.execMsgId,
+                cursorCallId: nextExec.cursorCallId,
+                modelCallId: nextExec.modelCallId,
+            });
+        }
+        else {
+            logPluginInfo("Ignored duplicate Cursor MCP tool call event", {
+                toolCallId: nextExec.toolCallId,
+                toolName: nextExec.toolName,
+                source: nextExec.source,
+                execId: nextExec.execId,
+                execMsgId: nextExec.execMsgId,
+                cursorCallId: nextExec.cursorCallId,
+                modelCallId: nextExec.modelCallId,
+            });
+        }
         return;
     }
-    state.emittedToolCallIds.add(execKey);
+    state.emittedToolCallIds.add(nextExec.toolCallId);
     replacePendingExec(state, nextExec);
+    logPluginInfo("Emitting Cursor MCP tool call", {
+        toolCallId: nextExec.toolCallId,
+        toolName: nextExec.toolName,
+        source: nextExec.source,
+        execId: nextExec.execId,
+        execMsgId: nextExec.execMsgId,
+        cursorCallId: nextExec.cursorCallId,
+        modelCallId: nextExec.modelCallId,
+        decodedArgs: nextExec.decodedArgs,
+    });
     onMcpExec(nextExec);
 }
 export function processServerMessage(msg, blobStore, mcpTools, sendFrame, state, onText, onMcpExec, onCheckpoint, onTurnEnded, onUnsupportedMessage, onUnhandledExec) {
@@ -233,8 +265,19 @@ function handleInteractionUpdate(update, state, onText, onMcpExec, onTurnEnded,
     }
     else if (updateCase === "toolCallCompleted") {
         const exec = decodeInteractionToolCall(update.message.value, state);
-        if (exec)
+        if (exec) {
+            logPluginInfo("Received Cursor interaction MCP tool call", {
+                toolCallId: exec.toolCallId,
+                toolName: exec.toolName,
+                source: exec.source,
+                execId: exec.execId,
+                execMsgId: exec.execMsgId,
+                cursorCallId: exec.cursorCallId,
+                modelCallId: exec.modelCallId,
+                decodedArgs: exec.decodedArgs,
+            });
             emitPendingExec(exec, state, onMcpExec);
+        }
     }
     else if (updateCase === "turnEnded") {
         onTurnEnded?.();
@@ -290,6 +333,9 @@ function decodeInteractionToolCall(update, state) {
         toolCallId,
         toolName: mcpArgs.toolName || mcpArgs.name || "unknown_mcp_tool",
         decodedArgs,
+        source: "interaction",
+        cursorCallId: callId || undefined,
+        modelCallId: update.modelCallId,
     };
 }
 function handleInteractionQuery(query, sendFrame, onUnsupportedMessage) {
@@ -448,7 +494,16 @@ function handleExecMessage(execMsg, mcpTools, sendFrame, state, onMcpExec, onUnh
             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,
+        });
         emitPendingExec(exec, state, onMcpExec);
         return;
     }

package/dist/proxy/types.d.ts

@@ -14,6 +14,9 @@ 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 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@playwo/opencode-cursor-oauth",
-  "version": "0.0.0-dev.6338d5591e37",
+  "version": "0.0.0-dev.67ecd4697583",
   "description": "OpenCode plugin that connects Cursor's API to OpenCode via OAuth, model discovery, and a local OpenAI-compatible proxy.",
   "license": "MIT",
   "type": "module",