@playwo/opencode-cursor-oauth 0.0.0-dev.762b07a81479 → 0.0.0-dev.825419c3fcde

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";
@@ -8,7 +8,7 @@ import { updateConversationCheckpoint, syncStoredBlobStore, } from "./state-sync
 import { SSE_HEADERS } from "./sse";
 import { computeUsage, createConnectFrameParser, createThinkingTagFilter, parseConnectEndStream, processServerMessage, scheduleBridgeEnd, } from "./stream-dispatch";
 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;
@@ -27,8 +27,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 ?? "";
@@ -49,6 +47,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;
@@ -77,7 +88,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;
@@ -90,7 +101,13 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools,
                             sendSSE(makeChunk({ content }));
                         }
                     }, (exec) => {
-                        state.pendingExecs.push(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)
@@ -129,6 +146,7 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools,
                             bridge,
                             heartbeatTimer,
                             blobStore,
+                            cloudRule,
                             mcpTools,
                             pendingExecs: state.pendingExecs,
                             modelId,
@@ -193,17 +211,29 @@ 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),
+                });
                 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) {
@@ -223,11 +253,7 @@ 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");
                 }
             });
         },
@@ -251,11 +277,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: [
@@ -265,6 +316,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
@@ -305,7 +383,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";
@@ -7,9 +7,22 @@ import { handleNonStreamingResponse, handleStreamingResponse, handleToolResultRe
 import { handleTitleGenerationRequest } from "./title";
 export function handleChatCompletion(body, accessToken, context = {}) {
     const parsed = parseMessages(body.messages);
-    const { systemPrompt, userText, turns, toolResults, pendingAssistantSummary, completedTurnsFingerprint, assistantContinuation, } = parsed;
+    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) {
@@ -79,27 +108,30 @@ export function handleChatCompletion(body, accessToken, context = {}) {
     stored.completedTurnsFingerprint = completedTurnsFingerprint;
     stored.lastAccessMs = Date.now();
     evictStaleConversations();
-    if (assistantContinuation) {
-        return new Response(JSON.stringify({
-            error: {
-                message: "Assistant-last continuation is not supported by the Cursor provider",
-                type: "invalid_request_error",
-            },
-        }), { status: 400, headers: { "Content-Type": "application/json" } });
-    }
     // 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,

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/server.js

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

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

@@ -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;