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

package/dist/proxy/bridge-streaming.js

@@ -1,17 +1,22 @@
 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 sortedIds(values) {
+    return [...values].sort();
+}
+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;
@@ -32,6 +37,8 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools,
             let assistantText = metadata.assistantSeedText ?? "";
             let mcpExecReceived = false;
             let endStreamError = null;
+            let toolCallsFlushed = false;
+            const streamedToolCalls = new Map();
             const sendSSE = (data) => {
                 if (closed)
                     return;
@@ -47,6 +54,19 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools,
                     return;
                 controller.enqueue(encoder.encode("data: [DONE]\n\n"));
             };
+            const failStream = (message, code) => {
+                if (closed)
+                    return;
+                sendSSE({
+                    error: {
+                        message,
+                        type: "server_error",
+                        ...(code ? { code } : {}),
+                    },
+                });
+                sendDone();
+                closeController();
+            };
             const closeController = () => {
                 if (closed)
                     return;
@@ -72,10 +92,145 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools,
                     usage: { prompt_tokens, completion_tokens, total_tokens },
                 };
             };
+            const ensureStreamedToolCall = (toolCallId, toolName) => {
+                const existing = streamedToolCalls.get(toolCallId);
+                if (existing) {
+                    if (toolName && existing.toolName !== toolName) {
+                        existing.toolName = toolName;
+                    }
+                    return existing;
+                }
+                const createdState = {
+                    index: state.toolCallIndex++,
+                    toolName,
+                    started: false,
+                };
+                streamedToolCalls.set(toolCallId, createdState);
+                return createdState;
+            };
+            const emitPendingToolStart = (toolCallId, toolName, source) => {
+                if (!toolName)
+                    return;
+                const toolCall = ensureStreamedToolCall(toolCallId, toolName);
+                if (toolCall.started)
+                    return;
+                toolCall.started = true;
+                logPluginInfo("Streaming pending Cursor tool-call start", {
+                    modelId,
+                    bridgeKey,
+                    convKey,
+                    toolCallId,
+                    toolName,
+                    index: toolCall.index,
+                    source,
+                });
+                sendSSE(makeChunk({
+                    tool_calls: [
+                        {
+                            index: toolCall.index,
+                            id: toolCallId,
+                            type: "function",
+                            function: {
+                                name: toolCall.toolName,
+                                arguments: "",
+                            },
+                        },
+                    ],
+                }));
+            };
+            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;
+                const flushed = tagFilter.flush();
+                if (flushed.reasoning)
+                    sendSSE(makeChunk({ reasoning_content: flushed.reasoning }));
+                if (flushed.content) {
+                    assistantText += flushed.content;
+                    sendSSE(makeChunk({ content: flushed.content }));
+                }
+                const assistantSeedText = [
+                    assistantText.trim(),
+                    state.pendingExecs
+                        .map((exec) => formatToolCallSummary({
+                        id: exec.toolCallId,
+                        type: "function",
+                        function: {
+                            name: exec.toolName,
+                            arguments: exec.decodedArgs,
+                        },
+                    }))
+                        .join("\n\n"),
+                ]
+                    .filter(Boolean)
+                    .join("\n\n");
+                activeBridges.set(bridgeKey, {
+                    bridge,
+                    heartbeatTimer,
+                    blobStore,
+                    cloudRule,
+                    mcpTools,
+                    pendingExecs: [...state.pendingExecs],
+                    modelId,
+                    metadata: {
+                        ...metadata,
+                        assistantSeedText,
+                    },
+                    diagnostics: {
+                        announcedToolCallIds: [],
+                        publishedToolCallIds: state.pendingExecs.map((exec) => exec.toolCallId),
+                        lastMcpUpdate: "publish",
+                        publishedAtMs: Date.now(),
+                    },
+                });
+                logPluginInfo("Publishing Cursor tool-call envelope", {
+                    modelId,
+                    bridgeKey,
+                    convKey,
+                    source,
+                    pendingExecToolCallIds: sortedIds(state.pendingExecs.map((exec) => exec.toolCallId)),
+                    emittedToolCallIds: state.pendingExecs.map((exec) => exec.toolCallId),
+                    assistantSeedTextLength: assistantSeedText.length,
+                });
+                for (const exec of state.pendingExecs) {
+                    emitPendingToolStart(exec.toolCallId, exec.toolName, "publish");
+                    const streamedToolCall = ensureStreamedToolCall(exec.toolCallId, exec.toolName);
+                    sendSSE(makeChunk({
+                        tool_calls: [
+                            {
+                                index: streamedToolCall.index,
+                                function: {
+                                    arguments: exec.decodedArgs,
+                                },
+                            },
+                        ],
+                    }));
+                }
+                logPluginInfo("Stored active Cursor bridge for tool-result resume", {
+                    modelId,
+                    bridgeKey,
+                    convKey,
+                    diagnostics: activeBridges.get(bridgeKey)?.diagnostics,
+                    pendingExecToolCallIds: sortedIds(state.pendingExecs.map((exec) => exec.toolCallId)),
+                });
+                sendSSE(makeChunk({}, "tool_calls"));
+                sendDone();
+                closeController();
+            };
             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;
@@ -88,57 +243,143 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools,
                             sendSSE(makeChunk({ content }));
                         }
                     }, (exec) => {
-                        state.pendingExecs.push(exec);
+                        if (toolCallsFlushed) {
+                            logPluginWarn("Received Cursor MCP exec after tool-call envelope was already published", {
+                                modelId,
+                                bridgeKey,
+                                convKey,
+                                toolCallId: exec.toolCallId,
+                                toolName: exec.toolName,
+                                publishedToolCallIds: activeBridges.get(bridgeKey)?.diagnostics?.publishedToolCallIds ??
+                                    [],
+                            });
+                        }
+                        emitPendingToolStart(exec.toolCallId, exec.toolName, "exec");
+                        const pendingBefore = sortedIds(state.pendingExecs.map((candidate) => candidate.toolCallId));
+                        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)
-                            sendSSE(makeChunk({ reasoning_content: flushed.reasoning }));
-                        if (flushed.content) {
-                            assistantText += flushed.content;
-                            sendSSE(makeChunk({ content: flushed.content }));
+                        const pendingAfter = sortedIds(state.pendingExecs.map((candidate) => candidate.toolCallId));
+                        const existingActiveBridge = activeBridges.get(bridgeKey);
+                        if (existingActiveBridge) {
+                            existingActiveBridge.diagnostics = {
+                                announcedToolCallIds: existingActiveBridge.diagnostics?.announcedToolCallIds ?? [],
+                                publishedToolCallIds: existingActiveBridge.diagnostics?.publishedToolCallIds ?? [],
+                                lastMcpUpdate: `exec:${exec.toolCallId}`,
+                                publishedAtMs: existingActiveBridge.diagnostics?.publishedAtMs,
+                                lastResumeAttemptAtMs: existingActiveBridge.diagnostics?.lastResumeAttemptAtMs,
+                            };
                         }
-                        const assistantSeedText = [
-                            assistantText.trim(),
-                            formatToolCallSummary({
-                                id: exec.toolCallId,
-                                type: "function",
-                                function: {
-                                    name: exec.toolName,
-                                    arguments: exec.decodedArgs,
-                                },
-                            }),
-                        ]
-                            .filter(Boolean)
-                            .join("\n\n");
-                        sendSSE(makeChunk({
-                            tool_calls: [
-                                {
-                                    index: state.toolCallIndex++,
-                                    id: exec.toolCallId,
-                                    type: "function",
-                                    function: {
-                                        name: exec.toolName,
-                                        arguments: exec.decodedArgs,
-                                    },
-                                },
-                            ],
-                        }));
-                        activeBridges.set(bridgeKey, {
-                            bridge,
-                            heartbeatTimer,
-                            blobStore,
-                            mcpTools,
-                            pendingExecs: state.pendingExecs,
+                        logPluginInfo("Tracking Cursor MCP exec in streaming bridge", {
                             modelId,
-                            metadata: {
-                                ...metadata,
-                                assistantSeedText,
-                            },
+                            bridgeKey,
+                            convKey,
+                            toolCallId: exec.toolCallId,
+                            toolName: exec.toolName,
+                            pendingBefore,
+                            pendingAfter,
+                            hasStoredActiveBridge: Boolean(existingActiveBridge),
+                            storedActiveBridgePendingExecToolCallIds: existingActiveBridge
+                                ? sortedIds(existingActiveBridge.pendingExecs.map((candidate) => candidate.toolCallId))
+                                : [],
+                        });
+                    }, (info) => {
+                        if (toolCallsFlushed) {
+                            logPluginWarn("Received Cursor MCP interaction update after tool-call envelope was already published", {
+                                modelId,
+                                bridgeKey,
+                                convKey,
+                                updateCase: info.updateCase,
+                                toolCallId: info.toolCallId,
+                                publishedToolCallIds: activeBridges.get(bridgeKey)?.diagnostics?.publishedToolCallIds ??
+                                    [],
+                            });
+                        }
+                        if (info.updateCase !== "toolCallCompleted") {
+                            emitPendingToolStart(info.toolCallId, info.toolName ?? "", "interaction");
+                        }
+                        const existingActiveBridge = activeBridges.get(bridgeKey);
+                        if (existingActiveBridge) {
+                            existingActiveBridge.diagnostics = {
+                                announcedToolCallIds: existingActiveBridge.diagnostics?.announcedToolCallIds ?? [],
+                                publishedToolCallIds: existingActiveBridge.diagnostics?.publishedToolCallIds ?? [],
+                                lastMcpUpdate: `${info.updateCase}:${info.toolCallId}`,
+                                publishedAtMs: existingActiveBridge.diagnostics?.publishedAtMs,
+                                lastResumeAttemptAtMs: existingActiveBridge.diagnostics?.lastResumeAttemptAtMs,
+                            };
+                        }
+                    }, (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,
+                            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,
                         });
-                        sendSSE(makeChunk({}, "tool_calls"));
-                        sendDone();
-                        closeController();
-                    }, (checkpointBytes) => updateConversationCheckpoint(convKey, checkpointBytes), (info) => {
+                    }, (checkpointBytes) => {
+                        logPluginInfo("Received Cursor conversation checkpoint", {
+                            modelId,
+                            bridgeKey,
+                            convKey,
+                            toolCallsFlushed,
+                            pendingExecToolCallIds: sortedIds(state.pendingExecs.map((candidate) => candidate.toolCallId)),
+                        });
+                        updateConversationCheckpoint(convKey, checkpointBytes);
+                        bridgeCloseController.noteCheckpoint();
+                        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,
+                            bridgeKey,
+                            convKey,
+                            category: info.category,
+                            caseName: info.caseName,
+                            detail: info.detail,
+                        });
+                        scheduleBridgeEnd(bridge);
+                    }, (info) => {
                         endStreamError = new Error(`Cursor requested unsupported exec type: ${info.execCase}`);
                         logPluginError("Closing Cursor bridge after unsupported exec", {
                             modelId,
@@ -155,6 +396,15 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools,
                     // 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", {
@@ -180,17 +430,32 @@ 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),
+                    pendingExecToolCallIds: sortedIds(state.pendingExecs.map((exec) => exec.toolCallId)),
+                    storedActiveBridgeDiagnostics: activeBridges.get(bridgeKey)?.diagnostics,
+                });
+                bridgeCloseController.dispose();
                 clearInterval(heartbeatTimer);
                 stopKeepalive();
                 syncStoredBlobStore(convKey, blobStore);
                 if (endStreamError) {
                     activeBridges.delete(bridgeKey);
-                    if (!closed) {
-                        closed = true;
-                        controller.error(endStreamError);
-                    }
+                    failStream(endStreamError.message, "cursor_bridge_closed");
                     return;
                 }
                 if (!mcpExecReceived) {
@@ -210,15 +475,12 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools,
                 }
                 activeBridges.delete(bridgeKey);
                 if (code !== 0 && !closed) {
-                    sendSSE(makeChunk({ content: "\n[Error: bridge connection lost]" }));
-                    sendSSE(makeChunk({}, "stop"));
-                    sendSSE(makeUsageChunk());
-                    sendDone();
-                    closeController();
+                    failStream("Cursor bridge connection lost", "cursor_bridge_closed");
                 }
             });
         },
         cancel(reason) {
+            bridgeCloseController.dispose();
             stopKeepalive();
             clearInterval(heartbeatTimer);
             syncStoredBlobStore(convKey, blobStore);
@@ -238,11 +500,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);
 }
-export function handleToolResultResume(active, toolResults, bridgeKey, convKey) {
-    const { bridge, heartbeatTimer, blobStore, mcpTools, pendingExecs, modelId, metadata, } = active;
+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, cloudRule, mcpTools, pendingExecs, modelId, metadata, } = active;
     const resumeMetadata = {
         ...metadata,
         assistantSeedText: [
@@ -252,7 +539,73 @@ export function handleToolResultResume(active, toolResults, bridgeKey, convKey)
             .filter(Boolean)
             .join("\n\n"),
     };
-    for (const exec of pendingExecs) {
+    const pendingToolCallIds = new Set(pendingExecs.map((exec) => exec.toolCallId));
+    const toolResultIds = new Set(toolResults.map((result) => result.toolCallId));
+    const missingToolResultIds = pendingExecs
+        .map((exec) => exec.toolCallId)
+        .filter((toolCallId) => !toolResultIds.has(toolCallId));
+    const unexpectedToolResultIds = toolResults
+        .map((result) => result.toolCallId)
+        .filter((toolCallId) => !pendingToolCallIds.has(toolCallId));
+    const matchedPendingExecs = pendingExecs.filter((exec) => toolResultIds.has(exec.toolCallId));
+    logPluginInfo("Preparing Cursor tool-result resume", {
+        bridgeKey,
+        convKey,
+        modelId,
+        toolResults,
+        pendingExecs,
+        bridgeAlive: bridge.alive,
+        diagnostics: active.diagnostics,
+    });
+    if (active.diagnostics) {
+        active.diagnostics.lastResumeAttemptAtMs = Date.now();
+    }
+    const unresolved = await waitForResolvablePendingExecs(active, toolResults);
+    logPluginInfo("Resolved pending exec state before Cursor tool-result resume", {
+        bridgeKey,
+        convKey,
+        modelId,
+        toolResults,
+        pendingExecs,
+        unresolvedPendingExecs: unresolved,
+        diagnostics: active.diagnostics,
+    });
+    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" } });
+    }
+    if (missingToolResultIds.length > 0 || unexpectedToolResultIds.length > 0) {
+        logPluginError("Aborting Cursor tool-result resume because tool-call ids did not match", {
+            bridgeKey,
+            convKey,
+            modelId,
+            pendingToolCallIds: [...pendingToolCallIds],
+            toolResultIds: [...toolResultIds],
+            missingToolResultIds,
+            unexpectedToolResultIds,
+        });
+        clearInterval(heartbeatTimer);
+        bridge.end();
+        return new Response(JSON.stringify({
+            error: {
+                message: "Tool-result ids did not match the active Cursor MCP tool calls. Aborting instead of resuming a potentially stuck session.",
+                type: "invalid_request_error",
+                code: "cursor_tool_result_mismatch",
+                details: {
+                    missingToolResultIds,
+                    unexpectedToolResultIds,
+                },
+            },
+        }), { status: 400, headers: { "Content-Type": "application/json" } });
+    }
+    for (const exec of matchedPendingExecs) {
         const result = toolResults.find((toolResult) => toolResult.toolCallId === exec.toolCallId);
         const mcpResult = result
             ? create(McpResultSchema, {
@@ -292,7 +645,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,24 @@ 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,
+            diagnostics: activeBridge.diagnostics,
+        });
         activeBridges.delete(bridgeKey);
         if (activeBridge.bridge.alive) {
             if (activeBridge.modelId !== modelId) {
@@ -82,16 +112,27 @@ export function handleChatCompletion(body, accessToken, context = {}) {
     // Build the request. When tool results are present but the bridge died,
     // we must still include the last user text so Cursor has context.
     const mcpTools = buildMcpToolDefinitions(tools);
+    const hasPendingAssistantSummary = pendingAssistantSummary.trim().length > 0;
     const needsInitialHandoff = !stored.checkpoint &&
-        (turns.length > 0 || pendingAssistantSummary || toolResults.length > 0);
+        (turns.length > 0 || hasPendingAssistantSummary || toolResults.length > 0);
     const replayTurns = needsInitialHandoff ? [] : turns;
     let effectiveUserText = needsInitialHandoff
         ? buildInitialHandoffPrompt(userText, turns, pendingAssistantSummary, toolResults)
-        : toolResults.length > 0
+        : toolResults.length > 0 || hasPendingAssistantSummary
             ? buildToolResumePrompt(userText, pendingAssistantSummary, toolResults)
             : 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,