@playwo/opencode-cursor-oauth 0.0.0-dev.4696faa690e4 → 0.0.0-dev.4a26f78d4622

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

@@ -6,7 +6,6 @@ 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";
-const MCP_TOOL_BATCH_WINDOW_MS = 150;
 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);
@@ -34,19 +33,8 @@ async function collectFullResponse(payload, accessToken, modelId, convKey, metad
     let fullText = "";
     let endStreamError = null;
     const pendingToolCalls = [];
-    let toolCallEndTimer;
     const { bridge, heartbeatTimer } = await startBridge(accessToken, payload.requestBytes);
     const bridgeCloseController = createBridgeCloseController(bridge);
-    const stopToolCallEndTimer = () => {
-        if (!toolCallEndTimer)
-            return;
-        clearTimeout(toolCallEndTimer);
-        toolCallEndTimer = undefined;
-    };
-    const scheduleToolCallBridgeEnd = () => {
-        stopToolCallEndTimer();
-        toolCallEndTimer = setTimeout(() => scheduleBridgeEnd(bridge), MCP_TOOL_BATCH_WINDOW_MS);
-    };
     const state = {
         toolCallIndex: 0,
         pendingExecs: [],
@@ -78,11 +66,18 @@ async function collectFullResponse(payload, accessToken, modelId, convKey, metad
                 else {
                     pendingToolCalls.push(toolCall);
                 }
-                scheduleToolCallBridgeEnd();
-            }, (_info) => { }, (checkpointBytes) => {
+            }, (_info) => { }, undefined, (checkpointBytes) => {
                 updateConversationCheckpoint(convKey, checkpointBytes);
                 bridgeCloseController.noteCheckpoint();
-            }, () => bridgeCloseController.noteTurnEnded(), (info) => {
+                if (pendingToolCalls.length > 0) {
+                    scheduleBridgeEnd(bridge);
+                }
+            }, () => {
+                bridgeCloseController.noteTurnEnded();
+                if (pendingToolCalls.length > 0) {
+                    scheduleBridgeEnd(bridge);
+                }
+            }, (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,
@@ -120,7 +115,6 @@ async function collectFullResponse(payload, accessToken, modelId, convKey, metad
     }));
     bridge.onClose(() => {
         bridgeCloseController.dispose();
-        stopToolCallEndTimer();
         clearInterval(heartbeatTimer);
         syncStoredBlobStore(convKey, payload.blobStore);
         const flushed = tagFilter.flush();

package/dist/proxy/bridge-streaming.js

@@ -9,7 +9,6 @@ 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;
-const MCP_TOOL_BATCH_WINDOW_MS = 150;
 function sortedIds(values) {
     return [...values].sort();
 }
@@ -17,7 +16,6 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, cloudRule
     const completionId = `chatcmpl-${crypto.randomUUID().replace(/-/g, "").slice(0, 28)}`;
     const created = Math.floor(Date.now() / 1000);
     let keepaliveTimer;
-    let toolCallFlushTimer;
     const bridgeCloseController = createBridgeCloseController(bridge);
     const stopKeepalive = () => {
         if (!keepaliveTimer)
@@ -25,12 +23,6 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, cloudRule
         clearInterval(keepaliveTimer);
         keepaliveTimer = undefined;
     };
-    const stopToolCallFlushTimer = () => {
-        if (!toolCallFlushTimer)
-            return;
-        clearTimeout(toolCallFlushTimer);
-        toolCallFlushTimer = undefined;
-    };
     const stream = new ReadableStream({
         start(controller) {
             const encoder = new TextEncoder();
@@ -80,7 +72,6 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, cloudRule
                     return;
                 closed = true;
                 stopKeepalive();
-                stopToolCallFlushTimer();
                 controller.close();
             };
             const makeChunk = (delta, finishReason = null) => ({
@@ -147,20 +138,20 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, cloudRule
                     ],
                 }));
             };
-            const publishPendingToolCalls = () => {
+            const publishPendingToolCalls = (source) => {
                 if (closed || toolCallsFlushed || state.pendingExecs.length === 0)
                     return;
                 logPluginInfo("Evaluating Cursor tool-call publish", {
                     modelId,
                     bridgeKey,
                     convKey,
+                    source,
                     pendingExecToolCallIds: sortedIds(state.pendingExecs.map((exec) => exec.toolCallId)),
                     toolCallsFlushed,
                     mcpExecReceived,
                     nowMs: Date.now(),
                 });
                 toolCallsFlushed = true;
-                stopToolCallFlushTimer();
                 const flushed = tagFilter.flush();
                 if (flushed.reasoning)
                     sendSSE(makeChunk({ reasoning_content: flushed.reasoning }));
@@ -206,6 +197,7 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, cloudRule
                     modelId,
                     bridgeKey,
                     convKey,
+                    source,
                     pendingExecToolCallIds: sortedIds(state.pendingExecs.map((exec) => exec.toolCallId)),
                     emittedToolCallIds: state.pendingExecs.map((exec) => exec.toolCallId),
                     assistantSeedTextLength: assistantSeedText.length,
@@ -235,19 +227,6 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, cloudRule
                 sendDone();
                 closeController();
             };
-            const schedulePendingToolCallPublish = () => {
-                if (toolCallsFlushed)
-                    return;
-                stopToolCallFlushTimer();
-                logPluginInfo("Scheduling Cursor tool-call publish", {
-                    modelId,
-                    bridgeKey,
-                    convKey,
-                    delayMs: MCP_TOOL_BATCH_WINDOW_MS,
-                    pendingExecToolCallIds: sortedIds(state.pendingExecs.map((exec) => exec.toolCallId)),
-                });
-                toolCallFlushTimer = setTimeout(publishPendingToolCalls, MCP_TOOL_BATCH_WINDOW_MS);
-            };
             const processChunk = createConnectFrameParser((messageBytes) => {
                 try {
                     const serverMessage = fromBinary(AgentServerMessageSchema, messageBytes);
@@ -309,7 +288,6 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, cloudRule
                                 ? sortedIds(existingActiveBridge.pendingExecs.map((candidate) => candidate.toolCallId))
                                 : [],
                         });
-                        schedulePendingToolCallPublish();
                     }, (info) => {
                         if (toolCallsFlushed) {
                             logPluginWarn("Received Cursor MCP interaction update after tool-call envelope was already published", {
@@ -335,20 +313,62 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, cloudRule
                                 lastResumeAttemptAtMs: existingActiveBridge.diagnostics?.lastResumeAttemptAtMs,
                             };
                         }
-                        logPluginInfo("Tracking Cursor MCP interaction state in streaming bridge", {
+                    }, (info) => {
+                        const existingActiveBridge = activeBridges.get(bridgeKey);
+                        if (existingActiveBridge) {
+                            existingActiveBridge.diagnostics = {
+                                announcedToolCallIds: existingActiveBridge.diagnostics?.announcedToolCallIds ?? [],
+                                publishedToolCallIds: existingActiveBridge.diagnostics?.publishedToolCallIds ?? [],
+                                lastMcpUpdate: info.updateCase === "stepCompleted"
+                                    ? `${info.updateCase}:${info.stepId}:${info.stepDurationMs ?? "unknown"}`
+                                    : `${info.updateCase}:${info.stepId}`,
+                                publishedAtMs: existingActiveBridge.diagnostics?.publishedAtMs,
+                                lastResumeAttemptAtMs: existingActiveBridge.diagnostics?.lastResumeAttemptAtMs,
+                            };
+                        }
+                        logPluginInfo("Tracking Cursor step boundary in streaming bridge", {
                             modelId,
                             bridgeKey,
                             convKey,
                             updateCase: info.updateCase,
-                            toolCallId: info.toolCallId,
+                            stepId: info.stepId,
+                            stepDurationMs: info.stepDurationMs,
+                            toolCallsFlushed,
+                            mcpExecReceived,
                             pendingExecToolCallIds: sortedIds(state.pendingExecs.map((candidate) => candidate.toolCallId)),
+                            streamedToolCallIds: sortedIds(streamedToolCalls.keys()),
                             hasStoredActiveBridge: Boolean(existingActiveBridge),
+                            storedActiveBridgePendingExecToolCallIds: existingActiveBridge
+                                ? sortedIds(existingActiveBridge.pendingExecs.map((candidate) => candidate.toolCallId))
+                                : [],
                             storedActiveBridgeDiagnostics: existingActiveBridge?.diagnostics,
                         });
                     }, (checkpointBytes) => {
+                        logPluginInfo("Received Cursor conversation checkpoint", {
+                            modelId,
+                            bridgeKey,
+                            convKey,
+                            toolCallsFlushed,
+                            pendingExecToolCallIds: sortedIds(state.pendingExecs.map((candidate) => candidate.toolCallId)),
+                        });
                         updateConversationCheckpoint(convKey, checkpointBytes);
                         bridgeCloseController.noteCheckpoint();
-                    }, () => bridgeCloseController.noteTurnEnded(), (info) => {
+                        if (state.pendingExecs.length > 0 && !toolCallsFlushed) {
+                            publishPendingToolCalls("checkpoint");
+                        }
+                    }, () => {
+                        logPluginInfo("Received Cursor turn-ended signal", {
+                            modelId,
+                            bridgeKey,
+                            convKey,
+                            toolCallsFlushed,
+                            pendingExecToolCallIds: sortedIds(state.pendingExecs.map((candidate) => candidate.toolCallId)),
+                        });
+                        bridgeCloseController.noteTurnEnded();
+                        if (state.pendingExecs.length > 0 && !toolCallsFlushed) {
+                            publishPendingToolCalls("turnEnded");
+                        }
+                    }, (info) => {
                         endStreamError = new Error(`Cursor returned unsupported ${info.category}: ${info.caseName}${info.detail ? ` (${info.detail})` : ""}`);
                         logPluginError("Closing Cursor bridge after unsupported message", {
                             modelId,
@@ -376,6 +396,15 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, cloudRule
                     // Skip unparseable messages.
                 }
             }, (endStreamBytes) => {
+                logPluginInfo("Received Cursor end-of-stream signal", {
+                    modelId,
+                    bridgeKey,
+                    convKey,
+                    byteLength: endStreamBytes.length,
+                });
+                if (state.pendingExecs.length > 0 && !toolCallsFlushed) {
+                    publishPendingToolCalls("endStream");
+                }
                 endStreamError = parseConnectEndStream(endStreamBytes);
                 if (endStreamError) {
                     logPluginError("Cursor stream returned Connect end-stream error", {
@@ -423,7 +452,6 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, cloudRule
                 bridgeCloseController.dispose();
                 clearInterval(heartbeatTimer);
                 stopKeepalive();
-                stopToolCallFlushTimer();
                 syncStoredBlobStore(convKey, blobStore);
                 if (endStreamError) {
                     activeBridges.delete(bridgeKey);
@@ -454,7 +482,6 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, cloudRule
         cancel(reason) {
             bridgeCloseController.dispose();
             stopKeepalive();
-            stopToolCallFlushTimer();
             clearInterval(heartbeatTimer);
             syncStoredBlobStore(convKey, blobStore);
             const active = activeBridges.get(bridgeKey);

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

@@ -18,6 +18,11 @@ export interface McpToolCallUpdateInfo {
     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;
@@ -45,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>, 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, 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, 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

@@ -128,10 +128,25 @@ 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, cloudRule, mcpTools, sendFrame, state, onText, onMcpExec, onMcpToolCallUpdate, onCheckpoint, onTurnEnded, onUnsupportedMessage, 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, onMcpToolCallUpdate, onTurnEnded, onUnsupportedMessage);
+        handleInteractionUpdate(msg.message.value, state, onText, onMcpToolCallUpdate, onStepUpdate, onTurnEnded, onUnsupportedMessage);
     }
     else if (msgCase === "kvServerMessage") {
         handleKvMessage(msg.message.value, blobStore, sendFrame);
@@ -164,19 +179,8 @@ export function processServerMessage(msg, blobStore, cloudRule, mcpTools, sendFr
         });
     }
 }
-function handleInteractionUpdate(update, state, onText, onMcpToolCallUpdate, onTurnEnded, onUnsupportedMessage) {
+function handleInteractionUpdate(update, state, onText, onMcpToolCallUpdate, onStepUpdate, 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 === "partialToolCall" ||
         updateCase === "toolCallStarted" ||
         updateCase === "toolCallCompleted") &&
@@ -193,6 +197,19 @@ function handleInteractionUpdate(update, state, onText, onMcpToolCallUpdate, onT
             });
         }
     }
+    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)
@@ -372,11 +389,6 @@ function handleKvMessage(kvMsg, blobStore, sendFrame) {
 }
 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,

package/package.json

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