@playwo/opencode-cursor-oauth 0.0.0-dev.2c48be2f48c9 → 0.0.0-dev.4463bb589222

package/dist/cursor/bidi-session.d.ts

@@ -1,5 +1,4 @@
 import { type CursorBaseRequestOptions } from "./headers";
-export declare function encodeBidiAppendRequest(dataHex: string, requestId: string, appendSeqno: number): Uint8Array;
 export interface CursorSession {
     write: (data: Uint8Array) => void;
     end: () => void;
@@ -8,6 +7,6 @@ export interface CursorSession {
     readonly alive: boolean;
 }
 export interface CreateCursorSessionOptions extends CursorBaseRequestOptions {
-    requestId: string;
+    initialRequestBytes: Uint8Array;
 }
 export declare function createCursorSession(options: CreateCursorSessionOptions): Promise<CursorSession>;

package/dist/cursor/bidi-session.js

@@ -1,149 +1,164 @@
-import { create, toBinary } from "@bufbuild/protobuf";
-import { BidiRequestIdSchema } from "../proto/agent_pb";
-import { CURSOR_API_URL } from "./config";
-import { concatBytes, encodeProtoMessageField, encodeProtoStringField, encodeProtoVarintField, frameConnectMessage, toFetchBody, } from "./connect-framing";
-import { buildCursorHeaders } from "./headers";
-import { errorDetails, logPluginError, logPluginWarn } from "../logger";
-export function encodeBidiAppendRequest(dataHex, requestId, appendSeqno) {
-    const requestIdBytes = toBinary(BidiRequestIdSchema, create(BidiRequestIdSchema, { requestId }));
-    return concatBytes([
-        encodeProtoStringField(1, dataHex),
-        encodeProtoMessageField(2, requestIdBytes),
-        encodeProtoVarintField(3, appendSeqno),
-    ]);
-}
+import { connect as connectHttp2, } from "node:http2";
+import { CURSOR_API_URL, CURSOR_CONNECT_PROTOCOL_VERSION } from "./config";
+import { frameConnectMessage } from "./connect-framing";
+import { buildCursorHeaderValues, } from "./headers";
+import { errorDetails, logPluginError } from "../logger";
+const CURSOR_BIDI_RUN_PATH = "/agent.v1.AgentService/Run";
 export async function createCursorSession(options) {
-    const response = await fetch(new URL("/agent.v1.AgentService/RunSSE", options.url ?? CURSOR_API_URL), {
-        method: "POST",
-        headers: buildCursorHeaders(options, "application/connect+proto", {
-            accept: "text/event-stream",
-            "connect-protocol-version": "1",
-        }),
-        body: toFetchBody(frameConnectMessage(toBinary(BidiRequestIdSchema, create(BidiRequestIdSchema, { requestId: options.requestId })))),
-    });
-    if (!response.ok || !response.body) {
-        const errorBody = await response.text().catch(() => "");
-        logPluginError("Cursor RunSSE request failed", {
-            requestId: options.requestId,
-            status: response.status,
-            responseBody: errorBody,
-        });
-        throw new Error(`RunSSE failed: ${response.status}${errorBody ? ` ${errorBody}` : ""}`);
+    if (options.initialRequestBytes.length === 0) {
+        throw new Error("Cursor sessions require an initial request message");
     }
-    const cbs = {
-        data: null,
-        close: null,
-    };
-    const abortController = new AbortController();
-    const reader = response.body.getReader();
-    let appendSeqno = 0;
-    let alive = true;
-    let closeCode = 0;
-    let writeChain = Promise.resolve();
-    const pendingChunks = [];
-    const finish = (code) => {
-        if (!alive)
-            return;
-        alive = false;
-        closeCode = code;
-        cbs.close?.(code);
-    };
-    const append = async (data) => {
-        const requestBody = encodeBidiAppendRequest(Buffer.from(data).toString("hex"), options.requestId, appendSeqno++);
-        const appendResponse = await fetch(new URL("/aiserver.v1.BidiService/BidiAppend", options.url ?? CURSOR_API_URL), {
-            method: "POST",
-            headers: buildCursorHeaders(options, "application/proto"),
-            body: toFetchBody(requestBody),
-            signal: abortController.signal,
-        });
-        if (!appendResponse.ok) {
-            const errorBody = await appendResponse.text().catch(() => "");
-            logPluginError("Cursor BidiAppend request failed", {
-                requestId: options.requestId,
-                appendSeqno: appendSeqno - 1,
-                status: appendResponse.status,
-                responseBody: errorBody,
-            });
-            throw new Error(`BidiAppend failed: ${appendResponse.status}${errorBody ? ` ${errorBody}` : ""}`);
-        }
-        await appendResponse.arrayBuffer().catch(() => undefined);
-    };
-    (async () => {
-        try {
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done) {
-                    finish(0);
-                    break;
-                }
-                if (value && value.length > 0) {
-                    const chunk = Buffer.from(value);
-                    if (cbs.data) {
-                        cbs.data(chunk);
-                    }
-                    else {
-                        pendingChunks.push(chunk);
-                    }
-                }
+    const target = new URL(CURSOR_BIDI_RUN_PATH, options.url ?? CURSOR_API_URL);
+    const authority = `${target.protocol}//${target.host}`;
+    const requestId = crypto.randomUUID();
+    return new Promise((resolve, reject) => {
+        const cbs = {
+            data: null,
+            close: null,
+        };
+        let session;
+        let stream;
+        let alive = true;
+        let closeCode = 0;
+        let opened = false;
+        let settled = false;
+        let statusCode = 0;
+        const pendingChunks = [];
+        const errorChunks = [];
+        const closeTransport = () => {
+            try {
+                stream?.close();
             }
-        }
-        catch (error) {
-            logPluginWarn("Cursor stream reader closed with error", {
-                requestId: options.requestId,
+            catch { }
+            try {
+                session?.close();
+            }
+            catch { }
+        };
+        const finish = (code) => {
+            if (!alive)
+                return;
+            alive = false;
+            closeCode = code;
+            cbs.close?.(code);
+            closeTransport();
+        };
+        const rejectOpen = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            alive = false;
+            closeTransport();
+            reject(error);
+        };
+        const resolveOpen = (sessionHandle) => {
+            if (settled)
+                return;
+            settled = true;
+            opened = true;
+            resolve(sessionHandle);
+        };
+        const handleTransportError = (message, error) => {
+            logPluginError(message, {
+                requestId,
+                url: target.toString(),
                 ...errorDetails(error),
             });
-            finish(alive ? 1 : closeCode);
-        }
-    })();
-    return {
-        get alive() {
-            return alive;
-        },
-        write(data) {
-            if (!alive)
+            if (!opened) {
+                rejectOpen(new Error(error instanceof Error ? error.message : String(error ?? message)));
                 return;
-            writeChain = writeChain
-                .then(() => append(data))
-                .catch((error) => {
-                logPluginError("Cursor stream append failed", {
-                    requestId: options.requestId,
-                    ...errorDetails(error),
-                });
+            }
+            finish(1);
+        };
+        const sessionHandle = {
+            get alive() {
+                return alive;
+            },
+            write(data) {
+                if (!alive || !stream)
+                    return;
                 try {
-                    abortController.abort();
+                    stream.write(frameConnectMessage(data));
                 }
-                catch { }
-                try {
-                    reader.cancel();
+                catch (error) {
+                    handleTransportError("Cursor HTTP/2 write failed", error);
+                }
+            },
+            end() {
+                finish(0);
+            },
+            onData(cb) {
+                cbs.data = cb;
+                while (pendingChunks.length > 0) {
+                    cb(pendingChunks.shift());
+                }
+            },
+            onClose(cb) {
+                if (!alive) {
+                    queueMicrotask(() => cb(closeCode));
                 }
-                catch { }
-                finish(1);
+                else {
+                    cbs.close = cb;
+                }
+            },
+        };
+        try {
+            session = connectHttp2(authority);
+            session.once("error", (error) => {
+                handleTransportError("Cursor HTTP/2 session failed", error);
             });
-        },
-        end() {
-            try {
-                abortController.abort();
-            }
-            catch { }
-            try {
-                reader.cancel();
-            }
-            catch { }
-            finish(0);
-        },
-        onData(cb) {
-            cbs.data = cb;
-            while (pendingChunks.length > 0) {
-                cb(pendingChunks.shift());
-            }
-        },
-        onClose(cb) {
-            if (!alive) {
-                queueMicrotask(() => cb(closeCode));
-            }
-            else {
-                cbs.close = cb;
-            }
-        },
-    };
+            const headers = {
+                ":method": "POST",
+                ":path": `${target.pathname}${target.search}`,
+                ...buildCursorHeaderValues(options, "application/connect+proto", {
+                    accept: "application/connect+proto",
+                    "connect-protocol-version": CURSOR_CONNECT_PROTOCOL_VERSION,
+                }),
+            };
+            stream = session.request(headers);
+            stream.once("response", (responseHeaders) => {
+                const statusHeader = responseHeaders[":status"];
+                statusCode =
+                    typeof statusHeader === "number"
+                        ? statusHeader
+                        : Number(statusHeader ?? 0);
+                if (statusCode >= 200 && statusCode < 300) {
+                    resolveOpen(sessionHandle);
+                }
+            });
+            stream.on("data", (chunk) => {
+                const buffer = Buffer.from(chunk);
+                if (!opened && statusCode >= 400) {
+                    errorChunks.push(buffer);
+                    return;
+                }
+                if (cbs.data) {
+                    cbs.data(buffer);
+                }
+                else {
+                    pendingChunks.push(buffer);
+                }
+            });
+            stream.once("end", () => {
+                if (!opened) {
+                    const errorBody = Buffer.concat(errorChunks).toString("utf8").trim();
+                    logPluginError("Cursor HTTP/2 Run request failed", {
+                        requestId,
+                        status: statusCode,
+                        responseBody: errorBody,
+                    });
+                    rejectOpen(new Error(`Run failed: ${statusCode || 1}${errorBody ? ` ${errorBody}` : ""}`));
+                    return;
+                }
+                finish(statusCode >= 200 && statusCode < 300 ? 0 : statusCode || 1);
+            });
+            stream.once("error", (error) => {
+                handleTransportError("Cursor HTTP/2 stream failed", error);
+            });
+            stream.write(frameConnectMessage(options.initialRequestBytes));
+        }
+        catch (error) {
+            handleTransportError("Cursor HTTP/2 transport setup failed", error);
+        }
+    });
 }

package/dist/cursor/index.d.ts

@@ -1,5 +1,5 @@
 export { CURSOR_API_URL, CURSOR_CLIENT_VERSION, CURSOR_CONNECT_PROTOCOL_VERSION, CONNECT_END_STREAM_FLAG, } from "./config";
 export { concatBytes, decodeConnectUnaryBody, encodeProtoMessageField, encodeProtoStringField, encodeProtoVarintField, encodeVarint, frameConnectMessage, toFetchBody, } from "./connect-framing";
 export { buildCursorHeaders, buildCursorHeaderValues, type CursorBaseRequestOptions, } from "./headers";
-export { createCursorSession, encodeBidiAppendRequest, type CreateCursorSessionOptions, type CursorSession, } from "./bidi-session";
+export { createCursorSession, type CreateCursorSessionOptions, type CursorSession, } from "./bidi-session";
 export { callCursorUnaryRpc, type CursorUnaryRpcOptions } from "./unary-rpc";

package/dist/cursor/index.js

@@ -1,5 +1,5 @@
 export { CURSOR_API_URL, CURSOR_CLIENT_VERSION, CURSOR_CONNECT_PROTOCOL_VERSION, CONNECT_END_STREAM_FLAG, } from "./config";
 export { concatBytes, decodeConnectUnaryBody, encodeProtoMessageField, encodeProtoStringField, encodeProtoVarintField, encodeVarint, frameConnectMessage, toFetchBody, } from "./connect-framing";
 export { buildCursorHeaders, buildCursorHeaderValues, } from "./headers";
-export { createCursorSession, encodeBidiAppendRequest, } from "./bidi-session";
+export { createCursorSession, } from "./bidi-session";
 export { callCursorUnaryRpc } from "./unary-rpc";

package/dist/cursor/unary-rpc.d.ts

@@ -4,7 +4,6 @@ export interface CursorUnaryRpcOptions {
     requestBody: Uint8Array;
     url?: string;
     timeoutMs?: number;
-    transport?: "auto" | "fetch" | "http2";
 }
 export declare function callCursorUnaryRpc(options: CursorUnaryRpcOptions): Promise<{
     body: Uint8Array;

package/dist/cursor/unary-rpc.js

@@ -1,67 +1,10 @@
 import { connect as connectHttp2, } from "node:http2";
 import { CURSOR_API_URL, CURSOR_CONNECT_PROTOCOL_VERSION } from "./config";
-import { toFetchBody } from "./connect-framing";
-import { buildCursorHeaders, buildCursorHeaderValues } from "./headers";
+import { buildCursorHeaderValues } from "./headers";
 import { errorDetails, logPluginError } from "../logger";
 export async function callCursorUnaryRpc(options) {
     const target = new URL(options.rpcPath, options.url ?? CURSOR_API_URL);
-    const transport = options.transport ?? "auto";
-    if (transport === "http2" ||
-        (transport === "auto" && target.protocol === "https:")) {
-        const http2Result = await callCursorUnaryRpcOverHttp2(options, target);
-        if (transport === "http2" ||
-            http2Result.timedOut ||
-            http2Result.exitCode !== 1) {
-            return http2Result;
-        }
-    }
-    return callCursorUnaryRpcOverFetch(options, target);
-}
-async function callCursorUnaryRpcOverFetch(options, target) {
-    let timedOut = false;
-    const timeoutMs = options.timeoutMs ?? 5_000;
-    const controller = new AbortController();
-    const timeout = timeoutMs > 0
-        ? setTimeout(() => {
-            timedOut = true;
-            controller.abort();
-        }, timeoutMs)
-        : undefined;
-    try {
-        const response = await fetch(target, {
-            method: "POST",
-            headers: buildCursorHeaders(options, "application/proto", {
-                accept: "application/proto, application/json",
-                "connect-protocol-version": CURSOR_CONNECT_PROTOCOL_VERSION,
-                "connect-timeout-ms": String(timeoutMs),
-            }),
-            body: toFetchBody(options.requestBody),
-            signal: controller.signal,
-        });
-        const body = new Uint8Array(await response.arrayBuffer());
-        return {
-            body,
-            exitCode: response.ok ? 0 : response.status,
-            timedOut,
-        };
-    }
-    catch {
-        logPluginError("Cursor unary fetch transport failed", {
-            rpcPath: options.rpcPath,
-            url: target.toString(),
-            timeoutMs,
-            timedOut,
-        });
-        return {
-            body: new Uint8Array(),
-            exitCode: timedOut ? 124 : 1,
-            timedOut,
-        };
-    }
-    finally {
-        if (timeout)
-            clearTimeout(timeout);
-    }
+    return callCursorUnaryRpcOverHttp2(options, target);
 }
 async function callCursorUnaryRpcOverHttp2(options, target) {
     const timeoutMs = options.timeoutMs ?? 5_000;

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-session.js

@@ -2,12 +2,10 @@ import { createCursorSession } from "../cursor/bidi-session";
 import { makeHeartbeatBytes } from "./stream-dispatch";
 const HEARTBEAT_INTERVAL_MS = 5_000;
 export async function startBridge(accessToken, requestBytes) {
-    const requestId = crypto.randomUUID();
     const bridge = await createCursorSession({
         accessToken,
-        requestId,
+        initialRequestBytes: requestBytes,
     });
-    bridge.write(requestBytes);
     const heartbeatTimer = setInterval(() => bridge.write(makeHeartbeatBytes()), HEARTBEAT_INTERVAL_MS);
     return { bridge, heartbeatTimer };
 }

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

@@ -1,5 +1,5 @@
 import { create, toBinary } from "@bufbuild/protobuf";
-import { AgentClientMessageSchema, ClientHeartbeatSchema, ConversationStateStructureSchema, BackgroundShellSpawnResultSchema, DeleteResultSchema, DeleteRejectedSchema, DiagnosticsResultSchema, ExecClientMessageSchema, FetchErrorSchema, FetchResultSchema, GetBlobResultSchema, GrepErrorSchema, GrepResultSchema, KvClientMessageSchema, LsRejectedSchema, LsResultSchema, McpResultSchema, ReadRejectedSchema, ReadResultSchema, RequestContextResultSchema, RequestContextSchema, RequestContextSuccessSchema, SetBlobResultSchema, ShellRejectedSchema, ShellResultSchema, WriteRejectedSchema, WriteResultSchema, WriteShellStdinErrorSchema, WriteShellStdinResultSchema, } from "../proto/agent_pb";
+import { AgentClientMessageSchema, AskQuestionInteractionResponseSchema, AskQuestionRejectedSchema, AskQuestionResultSchema, ClientHeartbeatSchema, ConversationStateStructureSchema, BackgroundShellSpawnResultSchema, CreatePlanErrorSchema, CreatePlanRequestResponseSchema, CreatePlanResultSchema, DeleteResultSchema, DeleteRejectedSchema, DiagnosticsResultSchema, ExecClientMessageSchema, ExaFetchRequestResponseSchema, ExaFetchRequestResponse_RejectedSchema, ExaSearchRequestResponseSchema, ExaSearchRequestResponse_RejectedSchema, FetchErrorSchema, FetchResultSchema, GetBlobResultSchema, GrepErrorSchema, GrepResultSchema, InteractionResponseSchema, KvClientMessageSchema, LsRejectedSchema, LsResultSchema, McpResultSchema, ReadRejectedSchema, ReadResultSchema, RequestContextResultSchema, RequestContextSchema, RequestContextSuccessSchema, SetBlobResultSchema, ShellRejectedSchema, ShellResultSchema, SwitchModeRequestResponseSchema, SwitchModeRequestResponse_RejectedSchema, WebSearchRequestResponseSchema, WebSearchRequestResponse_RejectedSchema, WriteRejectedSchema, WriteResultSchema, WriteShellStdinErrorSchema, WriteShellStdinResultSchema, } from "../proto/agent_pb";
 import { CONNECT_END_STREAM_FLAG } from "../cursor/config";
 import { logPluginError, logPluginWarn } from "../logger";
 import { decodeMcpArgsMap } from "../openai/tools";
@@ -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,15 @@ 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") {
+        handleInteractionQuery(msg.message.value, sendFrame, onUnsupportedMessage);
+    }
     else if (msgCase === "conversationCheckpointUpdate") {
         const stateStructure = msg.message.value;
         if (stateStructure.tokenDetails) {
@@ -148,8 +157,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 +179,159 @@ 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,
+    };
+}
+function handleInteractionQuery(query, sendFrame, onUnsupportedMessage) {
+    const queryCase = query.query.case;
+    if (queryCase === "webSearchRequestQuery") {
+        const response = create(WebSearchRequestResponseSchema, {
+            result: {
+                case: "rejected",
+                value: create(WebSearchRequestResponse_RejectedSchema, {
+                    reason: "Native Cursor web search is not available in this environment. Use the provided MCP tool `websearch` instead.",
+                }),
+            },
+        });
+        sendInteractionResponse(query.id, "webSearchRequestResponse", response, sendFrame);
+        return;
+    }
+    if (queryCase === "askQuestionInteractionQuery") {
+        const response = create(AskQuestionInteractionResponseSchema, {
+            result: create(AskQuestionResultSchema, {
+                result: {
+                    case: "rejected",
+                    value: create(AskQuestionRejectedSchema, {
+                        reason: "Native Cursor question prompts are not available in this environment. Use the provided MCP tool `question` instead.",
+                    }),
+                },
+            }),
+        });
+        sendInteractionResponse(query.id, "askQuestionInteractionResponse", response, sendFrame);
+        return;
+    }
+    if (queryCase === "switchModeRequestQuery") {
+        const response = create(SwitchModeRequestResponseSchema, {
+            result: {
+                case: "rejected",
+                value: create(SwitchModeRequestResponse_RejectedSchema, {
+                    reason: "Cursor mode switching is not available in this environment. Continue using the current agent and the provided MCP tools.",
+                }),
+            },
+        });
+        sendInteractionResponse(query.id, "switchModeRequestResponse", response, sendFrame);
+        return;
+    }
+    if (queryCase === "exaSearchRequestQuery") {
+        const response = create(ExaSearchRequestResponseSchema, {
+            result: {
+                case: "rejected",
+                value: create(ExaSearchRequestResponse_RejectedSchema, {
+                    reason: "Native Cursor Exa search is not available in this environment. Use the provided MCP tool `websearch` instead.",
+                }),
+            },
+        });
+        sendInteractionResponse(query.id, "exaSearchRequestResponse", response, sendFrame);
+        return;
+    }
+    if (queryCase === "exaFetchRequestQuery") {
+        const response = create(ExaFetchRequestResponseSchema, {
+            result: {
+                case: "rejected",
+                value: create(ExaFetchRequestResponse_RejectedSchema, {
+                    reason: "Native Cursor Exa fetch is not available in this environment. Use the provided MCP tools `websearch` and `webfetch` instead.",
+                }),
+            },
+        });
+        sendInteractionResponse(query.id, "exaFetchRequestResponse", response, sendFrame);
+        return;
+    }
+    if (queryCase === "createPlanRequestQuery") {
+        const response = create(CreatePlanRequestResponseSchema, {
+            result: create(CreatePlanResultSchema, {
+                planUri: "",
+                result: {
+                    case: "error",
+                    value: create(CreatePlanErrorSchema, {
+                        error: "Native Cursor plan creation is not available in this environment. Use the provided MCP planning tools instead.",
+                    }),
+                },
+            }),
+        });
+        sendInteractionResponse(query.id, "createPlanRequestResponse", response, sendFrame);
+        return;
+    }
+    onUnsupportedMessage?.({
+        category: "interactionQuery",
+        caseName: queryCase ?? "undefined",
+    });
 }
 /** Send a KV client response back to Cursor. */
 function sendKvResponse(kvMsg, messageCase, value, sendFrame) {
@@ -179,6 +344,16 @@ function sendKvResponse(kvMsg, messageCase, value, sendFrame) {
     });
     sendFrame(toBinary(AgentClientMessageSchema, clientMsg));
 }
+function sendInteractionResponse(queryId, messageCase, value, sendFrame) {
+    const response = create(InteractionResponseSchema, {
+        id: queryId,
+        result: { case: messageCase, value: value },
+    });
+    const clientMessage = create(AgentClientMessageSchema, {
+        message: { case: "interactionResponse", value: response },
+    });
+    sendFrame(toBinary(AgentClientMessageSchema, clientMessage));
+}
 function handleKvMessage(kvMsg, blobStore, sendFrame) {
     const kvCase = kvMsg.message.case;
     if (kvCase === "getBlobArgs") {

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.4463bb589222",
   "description": "OpenCode plugin that connects Cursor's API to OpenCode via OAuth, model discovery, and a local OpenAI-compatible proxy.",
   "license": "MIT",
   "type": "module",