@playwo/opencode-cursor-oauth 0.0.0-dev.7fe465ca080f → 0.0.0-dev.825419c3fcde

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

@@ -38,14 +38,12 @@ 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) => {
         try {
             const serverMessage = fromBinary(AgentServerMessageSchema, messageBytes);
-            processServerMessage(serverMessage, payload.blobStore, payload.mcpTools, (data) => bridge.write(data), state, (text, isThinking) => {
+            processServerMessage(serverMessage, payload.blobStore, payload.cloudRule, payload.mcpTools, (data) => bridge.write(data), state, (text, isThinking) => {
                 if (isThinking)
                     return;
                 const { content } = tagFilter.process(text);

package/dist/proxy/bridge-streaming.js

@@ -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 ?? "";
@@ -90,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;
@@ -148,6 +146,7 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools,
                             bridge,
                             heartbeatTimer,
                             blobStore,
+                            cloudRule,
                             mcpTools,
                             pendingExecs: state.pendingExecs,
                             modelId,
@@ -217,6 +216,7 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools,
                 bridgeKey,
                 convKey,
                 mcpToolCount: mcpTools.length,
+                hasCloudRule: Boolean(cloudRule),
             });
             bridge.onData(processChunk);
             bridge.onClose((code) => {
@@ -284,7 +284,7 @@ export async function handleStreamingResponse(payload, accessToken, modelId, bri
         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));
@@ -306,7 +306,7 @@ async function waitForResolvablePendingExecs(active, toolResults, timeoutMs = 2_
     return unresolved;
 }
 export async function handleToolResultResume(active, toolResults, bridgeKey, convKey) {
-    const { bridge, heartbeatTimer, blobStore, mcpTools, pendingExecs, modelId, metadata, } = active;
+    const { bridge, heartbeatTimer, blobStore, cloudRule, mcpTools, pendingExecs, modelId, metadata, } = active;
     const resumeMetadata = {
         ...metadata,
         assistantSeedText: [
@@ -341,7 +341,7 @@ export async function handleToolResultResume(active, toolResults, bridgeKey, con
                 type: "invalid_request_error",
                 code: "cursor_missing_exec_metadata",
             },
-        }), { status: 409, headers: { "Content-Type": "application/json" } });
+        }), { status: 400, headers: { "Content-Type": "application/json" } });
     }
     for (const exec of pendingExecs) {
         const result = toolResults.find((toolResult) => toolResult.toolCallId === exec.toolCallId);
@@ -398,5 +398,5 @@ export async function handleToolResultResume(active, toolResults, bridgeKey, con
         });
         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/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/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;

package/dist/proxy/stream-dispatch.js

@@ -128,98 +128,16 @@ export function computeUsage(state) {
     const prompt_tokens = Math.max(0, total_tokens - completion_tokens);
     return { prompt_tokens, completion_tokens, total_tokens };
 }
-function replacePendingExec(state, exec) {
-    const existingIndex = state.pendingExecs.findIndex((candidate) => candidate.toolCallId === exec.toolCallId);
-    if (existingIndex >= 0) {
-        state.pendingExecs[existingIndex] = exec;
-        return;
-    }
-    state.pendingExecs.push(exec);
-}
-function hasUsableDecodedArgs(decodedArgs) {
-    const trimmed = decodedArgs.trim();
-    return trimmed !== "" && trimmed !== "{}";
-}
-function mergePendingExec(existing, incoming) {
-    const incomingHasExecMetadata = incoming.execMsgId !== 0;
-    const existingHasExecMetadata = existing.execMsgId !== 0;
-    return {
-        execId: incomingHasExecMetadata || !existing.execId ? incoming.execId : existing.execId,
-        execMsgId: incomingHasExecMetadata || !existingHasExecMetadata
-            ? incoming.execMsgId
-            : existing.execMsgId,
-        toolCallId: existing.toolCallId || incoming.toolCallId,
-        toolName: incoming.toolName && incoming.toolName !== "unknown_mcp_tool"
-            ? incoming.toolName
-            : existing.toolName,
-        decodedArgs: hasUsableDecodedArgs(incoming.decodedArgs)
-            ? incoming.decodedArgs
-            : existing.decodedArgs,
-        source: incomingHasExecMetadata ? incoming.source : existing.source ?? incoming.source,
-        cursorCallId: existing.cursorCallId || incoming.cursorCallId,
-        modelCallId: existing.modelCallId || incoming.modelCallId,
-    };
-}
-function emitPendingExec(exec, state, onMcpExec) {
-    const existing = state.pendingExecs.find((candidate) => candidate.toolCallId === exec.toolCallId);
-    const nextExec = existing ? mergePendingExec(existing, exec) : exec;
-    const hadActionableMetadata = (existing?.execMsgId ?? 0) !== 0;
-    const hasActionableMetadata = nextExec.execMsgId !== 0;
-    if (state.emittedToolCallIds.has(nextExec.toolCallId)) {
-        replacePendingExec(state, nextExec);
-        if (!hadActionableMetadata && hasActionableMetadata) {
-            logPluginInfo("Cursor MCP tool call metadata upgraded", {
-                toolCallId: nextExec.toolCallId,
-                toolName: nextExec.toolName,
-                source: nextExec.source,
-                execId: nextExec.execId,
-                execMsgId: nextExec.execMsgId,
-                cursorCallId: nextExec.cursorCallId,
-                modelCallId: nextExec.modelCallId,
-            });
-        }
-        else {
-            logPluginInfo("Ignored duplicate Cursor MCP tool call event", {
-                toolCallId: nextExec.toolCallId,
-                toolName: nextExec.toolName,
-                source: nextExec.source,
-                execId: nextExec.execId,
-                execMsgId: nextExec.execMsgId,
-                cursorCallId: nextExec.cursorCallId,
-                modelCallId: nextExec.modelCallId,
-            });
-        }
-        return;
-    }
-    state.emittedToolCallIds.add(nextExec.toolCallId);
-    replacePendingExec(state, nextExec);
-    logPluginInfo("Emitting Cursor MCP tool call", {
-        toolCallId: nextExec.toolCallId,
-        toolName: nextExec.toolName,
-        source: nextExec.source,
-        execId: nextExec.execId,
-        execMsgId: nextExec.execMsgId,
-        cursorCallId: nextExec.cursorCallId,
-        modelCallId: nextExec.modelCallId,
-        decodedArgs: nextExec.decodedArgs,
-    });
-    onMcpExec(nextExec);
-}
-export function processServerMessage(msg, blobStore, mcpTools, sendFrame, state, onText, onMcpExec, onCheckpoint, onTurnEnded, onUnsupportedMessage, onUnhandledExec) {
+export function processServerMessage(msg, blobStore, cloudRule, mcpTools, sendFrame, state, onText, onMcpExec, onCheckpoint, onTurnEnded, onUnsupportedMessage, onUnhandledExec) {
     const msgCase = msg.message.case;
-    if (msgCase !== "conversationCheckpointUpdate") {
-        logPluginInfo("Received Cursor server message", {
-            messageCase: msgCase ?? "undefined",
-        });
-    }
     if (msgCase === "interactionUpdate") {
-        handleInteractionUpdate(msg.message.value, state, onText, onMcpExec, onTurnEnded, onUnsupportedMessage);
+        handleInteractionUpdate(msg.message.value, state, onText, onTurnEnded, onUnsupportedMessage);
     }
     else if (msgCase === "kvServerMessage") {
         handleKvMessage(msg.message.value, blobStore, sendFrame);
     }
     else if (msgCase === "execServerMessage") {
-        handleExecMessage(msg.message.value, mcpTools, sendFrame, state, onMcpExec, onUnhandledExec);
+        handleExecMessage(msg.message.value, cloudRule, mcpTools, sendFrame, state, onMcpExec, onUnhandledExec);
     }
     else if (msgCase === "execServerControlMessage") {
         onUnsupportedMessage?.({
@@ -246,11 +164,12 @@ export function processServerMessage(msg, blobStore, mcpTools, sendFrame, state,
         });
     }
 }
-function handleInteractionUpdate(update, state, onText, onMcpExec, onTurnEnded, onUnsupportedMessage) {
+function handleInteractionUpdate(update, state, onText, onTurnEnded, onUnsupportedMessage) {
     const updateCase = update.message?.case;
-    if (updateCase !== "textDelta" &&
-        updateCase !== "thinkingDelta" &&
-        updateCase !== "tokenDelta") {
+    if (updateCase === "partialToolCall" ||
+        updateCase === "toolCallStarted" ||
+        updateCase === "toolCallCompleted" ||
+        updateCase === "turnEnded") {
         logPluginInfo("Received Cursor interaction update", {
             updateCase: updateCase ?? "undefined",
             callId: update.message?.value?.callId,
@@ -272,26 +191,18 @@ function handleInteractionUpdate(update, state, onText, onMcpExec, onTurnEnded,
         state.outputTokens += update.message.value.tokens ?? 0;
     }
     else if (updateCase === "partialToolCall") {
-        const partial = update.message.value;
-        if (partial.callId && partial.argsTextDelta) {
-            const existing = state.interactionToolArgsText.get(partial.callId) ?? "";
-            state.interactionToolArgsText.set(partial.callId, `${existing}${partial.argsTextDelta}`);
-        }
+        return;
     }
     else if (updateCase === "toolCallCompleted") {
-        const exec = decodeInteractionToolCall(update.message.value, state);
-        if (exec) {
-            logPluginInfo("Received Cursor interaction MCP tool call", {
-                toolCallId: exec.toolCallId,
-                toolName: exec.toolName,
-                source: exec.source,
-                execId: exec.execId,
-                execMsgId: exec.execMsgId,
-                cursorCallId: exec.cursorCallId,
-                modelCallId: exec.modelCallId,
-                decodedArgs: exec.decodedArgs,
+        const toolValue = update.message.value;
+        if (toolValue?.toolCall?.tool?.case === "mcpToolCall") {
+            logPluginInfo("Ignoring Cursor interaction MCP tool completion", {
+                callId: toolValue.callId,
+                modelCallId: toolValue.modelCallId,
+                toolCallId: toolValue.toolCall.tool.value?.args?.toolCallId || toolValue.callId,
+                toolName: toolValue.toolCall.tool.value?.args?.toolName ||
+                    toolValue.toolCall.tool.value?.args?.name,
             });
-            emitPendingExec(exec, state, onMcpExec);
         }
     }
     else if (updateCase === "turnEnded") {
@@ -315,43 +226,8 @@ function handleInteractionUpdate(update, state, onText, onMcpExec, onTurnEnded,
             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();
-    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;
-    }
-    if (callId)
-        state.interactionToolArgsText.delete(callId);
-    return {
-        execId: callId || toolCallId,
-        execMsgId: 0,
-        toolCallId,
-        toolName: mcpArgs.toolName || mcpArgs.name || "unknown_mcp_tool",
-        decodedArgs,
-        source: "interaction",
-        cursorCallId: callId || undefined,
-        modelCallId: update.modelCallId,
-    };
+    // Interaction tool-call updates are informational only. Resumable MCP tool
+    // execution comes from execServerMessage.mcpArgs.
 }
 function handleInteractionQuery(query, sendFrame, onUnsupportedMessage) {
     const queryCase = query.query.case;
@@ -478,7 +354,7 @@ function handleKvMessage(kvMsg, blobStore, sendFrame) {
         sendKvResponse(kvMsg, "setBlobResult", create(SetBlobResultSchema, {}), sendFrame);
     }
 }
-function handleExecMessage(execMsg, mcpTools, sendFrame, state, onMcpExec, onUnhandledExec) {
+function handleExecMessage(execMsg, cloudRule, mcpTools, sendFrame, state, onMcpExec, onUnhandledExec) {
     const execCase = execMsg.message.case;
     logPluginInfo("Received Cursor exec message", {
         execCase: execCase ?? "undefined",
@@ -498,6 +374,7 @@ function handleExecMessage(execMsg, mcpTools, sendFrame, state, onMcpExec, onUnh
             gitRepos: [],
             projectLayouts: [],
             mcpInstructions: [],
+            cloudRule,
             fileContents: {},
             customSubagents: [],
         });
@@ -529,7 +406,7 @@ function handleExecMessage(execMsg, mcpTools, sendFrame, state, onMcpExec, onUnh
             execMsgId: exec.execMsgId,
             decodedArgs: exec.decodedArgs,
         });
-        emitPendingExec(exec, state, onMcpExec);
+        onMcpExec(exec);
         return;
     }
     // --- Reject native Cursor tools ---

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

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

package/dist/proxy/types.d.ts

@@ -1,9 +1,10 @@
 import type { CursorSession } from "../cursor/bidi-session";
-import type { ConversationRequestMetadata } from "./conversation-meta";
 import type { McpToolDefinition } from "../proto/agent_pb";
+import type { ConversationRequestMetadata } from "./conversation-meta";
 export interface CursorRequestPayload {
     requestBytes: Uint8Array;
     blobStore: Map<string, Uint8Array>;
+    cloudRule?: string;
     mcpTools: McpToolDefinition[];
 }
 /** A pending tool execution waiting for results from the caller. */
@@ -23,6 +24,7 @@ export interface ActiveBridge {
     bridge: CursorSession;
     heartbeatTimer: NodeJS.Timeout;
     blobStore: Map<string, Uint8Array>;
+    cloudRule?: string;
     mcpTools: McpToolDefinition[];
     pendingExecs: PendingExec[];
     modelId: string;

package/package.json

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