@playwo/opencode-cursor-oauth 0.0.0-dev.2c48be2f48c9 → 0.0.0-dev.4258a6733133

package/dist/openai/messages.js

@@ -79,6 +79,11 @@ export function parseMessages(messages) {
             completedTurnStates = parsedTurns.slice(0, -1);
             userText = lastTurn.userText;
         }
+        else if (lastTurn.userText && hasAssistantSummary) {
+            completedTurnStates = parsedTurns.slice(0, -1);
+            userText = lastTurn.userText;
+            pendingAssistantSummary = summarizeTurnSegments(lastTurn.segments);
+        }
     }
     const turns = completedTurnStates
         .map((turn) => ({

package/dist/plugin/cursor-auth-plugin.js

@@ -110,7 +110,6 @@ export const CursorAuthPlugin = async (input) => {
         async "chat.headers"(incoming, output) {
             if (incoming.model.providerID !== CURSOR_PROVIDER_ID)
                 return;
-            output.headers["x-opencode-session-id"] = incoming.sessionID;
             output.headers["x-session-id"] = incoming.sessionID;
             if (incoming.agent) {
                 output.headers["x-opencode-agent"] = incoming.agent;

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

@@ -38,6 +38,8 @@ async function collectFullResponse(payload, accessToken, modelId, convKey, metad
         pendingExecs: [],
         outputTokens: 0,
         totalTokens: 0,
+        interactionToolArgsText: new Map(),
+        emittedToolCallIds: new Set(),
     };
     const tagFilter = createThinkingTagFilter();
     bridge.onData(createConnectFrameParser((messageBytes) => {
@@ -58,7 +60,17 @@ async function collectFullResponse(payload, accessToken, modelId, convKey, metad
                     },
                 });
                 scheduleBridgeEnd(bridge);
-            }, (checkpointBytes) => updateConversationCheckpoint(convKey, checkpointBytes), (info) => {
+            }, (checkpointBytes) => updateConversationCheckpoint(convKey, checkpointBytes), () => 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,
+                    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 non-streaming Cursor bridge after unsupported exec", {
                     modelId,

package/dist/proxy/bridge-streaming.js

@@ -27,6 +27,8 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools,
                 pendingExecs: [],
                 outputTokens: 0,
                 totalTokens: 0,
+                interactionToolArgsText: new Map(),
+                emittedToolCallIds: new Set(),
             };
             const tagFilter = createThinkingTagFilter();
             let assistantText = metadata.assistantSeedText ?? "";
@@ -47,6 +49,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;
@@ -138,7 +153,18 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools,
                         sendSSE(makeChunk({}, "tool_calls"));
                         sendDone();
                         closeController();
-                    }, (checkpointBytes) => updateConversationCheckpoint(convKey, checkpointBytes), (info) => {
+                    }, (checkpointBytes) => updateConversationCheckpoint(convKey, checkpointBytes), () => scheduleBridgeEnd(bridge), (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,
@@ -187,10 +213,7 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools,
                 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,11 +233,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");
                 }
             });
         },

package/dist/proxy/chat-completion.js

@@ -82,12 +82,13 @@ 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);

package/dist/proxy/cursor-request.d.ts

@@ -3,3 +3,4 @@ export declare function buildCursorRequest(modelId: string, systemPrompt: string
     userText: string;
     assistantText: string;
 }>, conversationId: string, checkpoint: Uint8Array | null, existingBlobStore?: Map<string, Uint8Array>): CursorRequestPayload;
+export declare function buildCursorResumeRequest(modelId: string, systemPrompt: string, conversationId: string, checkpoint: Uint8Array, existingBlobStore?: Map<string, Uint8Array>): CursorRequestPayload;

package/dist/proxy/cursor-request.js

@@ -1,6 +1,6 @@
 import { create, fromBinary, toBinary } from "@bufbuild/protobuf";
 import { createHash } from "node:crypto";
-import { AgentClientMessageSchema, AgentRunRequestSchema, ConversationActionSchema, ConversationStateStructureSchema, ConversationStepSchema, AgentConversationTurnStructureSchema, ConversationTurnStructureSchema, AssistantMessageSchema, ModelDetailsSchema, UserMessageActionSchema, UserMessageSchema, } from "../proto/agent_pb";
+import { AgentClientMessageSchema, AgentRunRequestSchema, ConversationActionSchema, ConversationStateStructureSchema, ConversationStepSchema, AgentConversationTurnStructureSchema, ConversationTurnStructureSchema, AssistantMessageSchema, 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)
@@ -64,6 +64,24 @@ export function buildCursorRequest(modelId, systemPrompt, userText, turns, conve
             value: create(UserMessageActionSchema, { userMessage }),
         },
     });
+    return buildRunRequest(modelId, conversationId, conversationState, action, blobStore);
+}
+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 conversationState = fromBinary(ConversationStateStructureSchema, checkpoint);
+    const action = create(ConversationActionSchema, {
+        action: {
+            case: "resumeAction",
+            value: create(ResumeActionSchema, {}),
+        },
+    });
+    return buildRunRequest(modelId, conversationId, conversationState, action, blobStore);
+}
+function buildRunRequest(modelId, conversationId, conversationState, action, blobStore) {
     const modelDetails = create(ModelDetailsSchema, {
         modelId,
         displayModelId: modelId,

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

@@ -7,6 +7,11 @@ export interface UnhandledExecInfo {
     execId: string;
     execMsgId: number;
 }
+export interface UnsupportedServerMessageInfo {
+    category: "agentMessage" | "interactionUpdate" | "interactionQuery" | "execServerControl" | "toolCall";
+    caseName: string;
+    detail?: string;
+}
 export declare function parseConnectEndStream(data: Uint8Array): Error | null;
 export declare function makeHeartbeatBytes(): Uint8Array;
 export declare function scheduleBridgeEnd(bridge: CursorSession): void;
@@ -34,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, onUnhandledExec?: (info: UnhandledExecInfo) => void): void;
+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;

package/dist/proxy/stream-dispatch.js

@@ -128,10 +128,10 @@ export function computeUsage(state) {
     const prompt_tokens = Math.max(0, total_tokens - completion_tokens);
     return { prompt_tokens, completion_tokens, total_tokens };
 }
-export function processServerMessage(msg, blobStore, mcpTools, sendFrame, state, onText, onMcpExec, onCheckpoint, onUnhandledExec) {
+export function processServerMessage(msg, blobStore, mcpTools, sendFrame, state, onText, onMcpExec, onCheckpoint, onTurnEnded, onUnsupportedMessage, onUnhandledExec) {
     const msgCase = msg.message.case;
     if (msgCase === "interactionUpdate") {
-        handleInteractionUpdate(msg.message.value, state, onText);
+        handleInteractionUpdate(msg.message.value, state, onText, onMcpExec, onTurnEnded, onUnsupportedMessage);
     }
     else if (msgCase === "kvServerMessage") {
         handleKvMessage(msg.message.value, blobStore, sendFrame);
@@ -139,6 +139,18 @@ export function processServerMessage(msg, blobStore, mcpTools, sendFrame, state,
     else if (msgCase === "execServerMessage") {
         handleExecMessage(msg.message.value, mcpTools, sendFrame, onMcpExec, onUnhandledExec);
     }
+    else if (msgCase === "execServerControlMessage") {
+        onUnsupportedMessage?.({
+            category: "execServerControl",
+            caseName: msg.message.value.message.case ?? "undefined",
+        });
+    }
+    else if (msgCase === "interactionQuery") {
+        onUnsupportedMessage?.({
+            category: "interactionQuery",
+            caseName: msg.message.value.query.case ?? "undefined",
+        });
+    }
     else if (msgCase === "conversationCheckpointUpdate") {
         const stateStructure = msg.message.value;
         if (stateStructure.tokenDetails) {
@@ -148,8 +160,14 @@ export function processServerMessage(msg, blobStore, mcpTools, sendFrame, state,
             onCheckpoint(toBinary(ConversationStateStructureSchema, stateStructure));
         }
     }
+    else {
+        onUnsupportedMessage?.({
+            category: "agentMessage",
+            caseName: msgCase ?? "undefined",
+        });
+    }
 }
-function handleInteractionUpdate(update, state, onText) {
+function handleInteractionUpdate(update, state, onText, onMcpExec, onTurnEnded, onUnsupportedMessage) {
     const updateCase = update.message?.case;
     if (updateCase === "textDelta") {
         const delta = update.message.value.text || "";
@@ -164,9 +182,75 @@ function handleInteractionUpdate(update, state, onText) {
     else if (updateCase === "tokenDelta") {
         state.outputTokens += update.message.value.tokens ?? 0;
     }
-    // toolCallStarted, partialToolCall, toolCallDelta, toolCallCompleted
-    // are intentionally ignored. MCP tool calls flow through the exec
-    // message path (mcpArgs → mcpResult), not interaction updates.
+    else if (updateCase === "partialToolCall") {
+        const partial = update.message.value;
+        if (partial.callId && partial.argsTextDelta) {
+            state.interactionToolArgsText.set(partial.callId, partial.argsTextDelta);
+        }
+    }
+    else if (updateCase === "toolCallCompleted") {
+        const exec = decodeInteractionToolCall(update.message.value, state);
+        if (exec)
+            onMcpExec(exec);
+    }
+    else if (updateCase === "turnEnded") {
+        onTurnEnded?.();
+    }
+    else if (updateCase === "toolCallStarted" ||
+        updateCase === "toolCallDelta" ||
+        updateCase === "thinkingCompleted" ||
+        updateCase === "userMessageAppended" ||
+        updateCase === "summary" ||
+        updateCase === "summaryStarted" ||
+        updateCase === "summaryCompleted" ||
+        updateCase === "heartbeat" ||
+        updateCase === "stepStarted" ||
+        updateCase === "stepCompleted") {
+        return;
+    }
+    else {
+        onUnsupportedMessage?.({
+            category: "interactionUpdate",
+            caseName: updateCase ?? "undefined",
+        });
+    }
+    // toolCallStarted, partialToolCall, toolCallDelta, and non-MCP
+    // toolCallCompleted updates are informational only. Actionable MCP tool
+    // calls may still appear here on some models, so we surface those, but we
+    // do not abort the bridge for native Cursor tool-call progress events.
+}
+function decodeInteractionToolCall(update, state) {
+    const callId = update.callId ?? "";
+    const toolCase = update.toolCall?.tool?.case;
+    if (toolCase !== "mcpToolCall")
+        return null;
+    const mcpArgs = update.toolCall?.tool?.value?.args;
+    if (!mcpArgs)
+        return null;
+    const toolCallId = mcpArgs.toolCallId || callId || crypto.randomUUID();
+    if (state.emittedToolCallIds.has(toolCallId))
+        return null;
+    const decodedMap = decodeMcpArgsMap(mcpArgs.args ?? {});
+    const partialArgsText = callId
+        ? state.interactionToolArgsText.get(callId)?.trim()
+        : undefined;
+    let decodedArgs = "{}";
+    if (Object.keys(decodedMap).length > 0) {
+        decodedArgs = JSON.stringify(decodedMap);
+    }
+    else if (partialArgsText) {
+        decodedArgs = partialArgsText;
+    }
+    state.emittedToolCallIds.add(toolCallId);
+    if (callId)
+        state.interactionToolArgsText.delete(callId);
+    return {
+        execId: callId || toolCallId,
+        execMsgId: 0,
+        toolCallId,
+        toolName: mcpArgs.toolName || mcpArgs.name || "unknown_mcp_tool",
+        decodedArgs,
+    };
 }
 /** Send a KV client response back to Cursor. */
 function sendKvResponse(kvMsg, messageCase, value, sendFrame) {

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

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

package/package.json

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