@playwo/opencode-cursor-oauth 0.0.0-dev.65683458d3f1 → 0.0.0-dev.9b39a4eb497b

package/dist/index.js

@@ -1,7 +1,7 @@
 import { generateCursorAuthParams, getTokenExpiry, pollCursorAuth, refreshCursorToken, } from "./auth";
 import { configurePluginLogger, errorDetails, logPluginError, logPluginWarn } from "./logger";
 import { getCursorModels } from "./models";
-import { OPENCODE_AGENT_HEADER, OPENCODE_MESSAGE_ID_HEADER, OPENCODE_SESSION_ID_HEADER, startProxy, stopProxy, } from "./proxy";
+import { startProxy, stopProxy, } from "./proxy";
 const CURSOR_PROVIDER_ID = "cursor";
 let lastModelDiscoveryError = null;
 /**
@@ -128,12 +128,14 @@ export const CursorAuthPlugin = async (input) => {
                 },
             ],
         },
-        async "chat.headers"(input, output) {
-            if (input.model.providerID !== CURSOR_PROVIDER_ID)
+        async "chat.headers"(incoming, output) {
+            if (incoming.model.providerID !== CURSOR_PROVIDER_ID)
                 return;
-            output.headers[OPENCODE_SESSION_ID_HEADER] = input.sessionID;
-            output.headers[OPENCODE_AGENT_HEADER] = input.agent;
-            output.headers[OPENCODE_MESSAGE_ID_HEADER] = input.message.id;
+            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.d.ts

@@ -1,6 +1,3 @@
-export declare const OPENCODE_SESSION_ID_HEADER = "x-opencode-session-id";
-export declare const OPENCODE_AGENT_HEADER = "x-opencode-agent";
-export declare const OPENCODE_MESSAGE_ID_HEADER = "x-opencode-message-id";
 interface CursorUnaryRpcOptions {
     accessToken: string;
     rpcPath: string;

package/dist/proxy.js

@@ -22,15 +22,11 @@ const CURSOR_API_URL = process.env.CURSOR_API_URL ?? "https://api2.cursor.sh";
 const CURSOR_CLIENT_VERSION = "cli-2026.01.09-231024f";
 const CURSOR_CONNECT_PROTOCOL_VERSION = "1";
 const CONNECT_END_STREAM_FLAG = 0b00000010;
-export const OPENCODE_SESSION_ID_HEADER = "x-opencode-session-id";
-export const OPENCODE_AGENT_HEADER = "x-opencode-agent";
-export const OPENCODE_MESSAGE_ID_HEADER = "x-opencode-message-id";
 const SSE_HEADERS = {
     "Content-Type": "text/event-stream",
     "Cache-Control": "no-cache",
     Connection: "keep-alive",
 };
-const EPHEMERAL_CURSOR_AGENTS = new Set(["title", "summary"]);
 // Active bridges keyed by a session token (derived from conversation state).
 // When tool_calls are returned, the bridge stays alive. The next request
 // with tool results looks up the bridge and sends mcpResult messages.
@@ -45,6 +41,31 @@ function evictStaleConversations() {
         }
     }
 }
+function normalizeAgentKey(agentKey) {
+    const trimmed = agentKey?.trim();
+    return trimmed ? trimmed : "default";
+}
+function hashString(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+function createStoredConversation() {
+    return {
+        conversationId: crypto.randomUUID(),
+        checkpoint: null,
+        blobStore: new Map(),
+        lastAccessMs: Date.now(),
+        systemPromptHash: "",
+        completedTurnsFingerprint: "",
+    };
+}
+function resetStoredConversation(stored) {
+    stored.conversationId = crypto.randomUUID();
+    stored.checkpoint = null;
+    stored.blobStore = new Map();
+    stored.lastAccessMs = Date.now();
+    stored.systemPromptHash = "";
+    stored.completedTurnsFingerprint = "";
+}
 /** Connect protocol frame: [1-byte flags][4-byte BE length][payload] */
 function frameConnectMessage(data, flags = 0) {
     const frame = Buffer.alloc(5 + data.length);
@@ -475,11 +496,11 @@ export async function startProxy(getAccessToken, models = []) {
                         throw new Error("Cursor proxy access token provider not configured");
                     }
                     const accessToken = await proxyAccessTokenProvider();
-                    return handleChatCompletion(body, accessToken, {
-                        sessionID: req.headers.get(OPENCODE_SESSION_ID_HEADER) ?? undefined,
-                        agent: req.headers.get(OPENCODE_AGENT_HEADER) ?? undefined,
-                        messageID: req.headers.get(OPENCODE_MESSAGE_ID_HEADER) ?? undefined,
-                    });
+                    const sessionId = req.headers.get("x-opencode-session-id")
+                        ?? req.headers.get("x-session-id")
+                        ?? undefined;
+                    const agentKey = req.headers.get("x-opencode-agent") ?? undefined;
+                    return handleChatCompletion(body, accessToken, { sessionId, agentKey });
                 }
                 catch (err) {
                     const message = err instanceof Error ? err.message : String(err);
@@ -517,10 +538,15 @@ export function stopProxy() {
     activeBridges.clear();
     conversationStates.clear();
 }
-function handleChatCompletion(body, accessToken, requestScope = {}) {
-    const { systemPrompt, userText, turns, toolResults } = parseMessages(body.messages);
+function handleChatCompletion(body, accessToken, context = {}) {
+    const parsed = parseMessages(body.messages);
+    const { systemPrompt, userText, turns, toolResults, pendingAssistantSummary, completedTurnsFingerprint, } = parsed;
     const modelId = body.model;
-    const tools = body.tools ?? [];
+    const normalizedAgentKey = normalizeAgentKey(context.agentKey);
+    const isTitleAgent = normalizedAgentKey === "title";
+    const tools = isTitleAgent
+        ? []
+        : selectToolsForChoice(body.tools ?? [], body.tool_choice);
     if (!userText && toolResults.length === 0) {
         return new Response(JSON.stringify({
             error: {
@@ -529,16 +555,24 @@ function handleChatCompletion(body, accessToken, requestScope = {}) {
             },
         }), { status: 400, headers: { "Content-Type": "application/json" } });
     }
-    // bridgeKey: model-specific, for active tool-call bridges
+    // bridgeKey: session/agent-scoped, for active tool-call bridges
     // convKey: model-independent, for conversation state that survives model switches
-    const bridgeKey = deriveBridgeKey(modelId, body.messages, requestScope);
-    const convKey = deriveConversationKey(body.messages, requestScope);
+    const bridgeKey = deriveBridgeKey(modelId, body.messages, context.sessionId, context.agentKey);
+    const convKey = deriveConversationKey(body.messages, context.sessionId, context.agentKey);
     const activeBridge = activeBridges.get(bridgeKey);
     if (activeBridge && toolResults.length > 0) {
         activeBridges.delete(bridgeKey);
         if (activeBridge.bridge.alive) {
+            if (activeBridge.modelId !== modelId) {
+                logPluginWarn("Resuming pending Cursor tool call on original model after model switch", {
+                    requestedModelId: modelId,
+                    resumedModelId: activeBridge.modelId,
+                    convKey,
+                    bridgeKey,
+                });
+            }
             // Resume the live bridge with tool results
-            return handleToolResultResume(activeBridge, toolResults, modelId, bridgeKey, convKey);
+            return handleToolResultResume(activeBridge, toolResults, bridgeKey, convKey);
         }
         // Bridge died (timeout, server disconnect, etc.).
         // Clean up and fall through to start a fresh bridge.
@@ -553,28 +587,52 @@ function handleChatCompletion(body, accessToken, requestScope = {}) {
     }
     let stored = conversationStates.get(convKey);
     if (!stored) {
-        stored = {
-            conversationId: crypto.randomUUID(),
-            checkpoint: null,
-            blobStore: new Map(),
-            lastAccessMs: Date.now(),
-        };
+        stored = createStoredConversation();
         conversationStates.set(convKey, stored);
     }
+    const systemPromptHash = hashString(systemPrompt);
+    if (stored.checkpoint
+        && (stored.systemPromptHash !== systemPromptHash
+            || (turns.length > 0 && stored.completedTurnsFingerprint !== completedTurnsFingerprint))) {
+        resetStoredConversation(stored);
+    }
+    stored.systemPromptHash = systemPromptHash;
+    stored.completedTurnsFingerprint = completedTurnsFingerprint;
     stored.lastAccessMs = Date.now();
     evictStaleConversations();
     // 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 effectiveUserText = userText || (toolResults.length > 0
-        ? toolResults.map((r) => r.content).join("\n")
-        : "");
-    const payload = buildCursorRequest(modelId, systemPrompt, effectiveUserText, turns, stored.conversationId, stored.checkpoint, stored.blobStore);
+    const needsInitialHandoff = !stored.checkpoint && (turns.length > 0 || pendingAssistantSummary || toolResults.length > 0);
+    const replayTurns = needsInitialHandoff ? [] : turns;
+    let effectiveUserText = needsInitialHandoff
+        ? buildInitialHandoffPrompt(userText, turns, pendingAssistantSummary, toolResults)
+        : toolResults.length > 0
+            ? buildToolResumePrompt(userText, pendingAssistantSummary, toolResults)
+            : userText;
+    if (isTitleAgent) {
+        effectiveUserText = buildTitleUserPrompt(systemPrompt, effectiveUserText);
+    }
+    const payload = buildCursorRequest(modelId, systemPrompt, effectiveUserText, replayTurns, stored.conversationId, stored.checkpoint, stored.blobStore);
     payload.mcpTools = mcpTools;
     if (body.stream === false) {
-        return handleNonStreamingResponse(payload, accessToken, modelId, convKey);
+        return handleNonStreamingResponse(payload, accessToken, modelId, convKey, {
+            systemPrompt,
+            systemPromptHash,
+            completedTurnsFingerprint,
+            turns,
+            userText,
+            agentKey: normalizedAgentKey,
+        });
     }
-    return handleStreamingResponse(payload, accessToken, modelId, bridgeKey, convKey);
+    return handleStreamingResponse(payload, accessToken, modelId, bridgeKey, convKey, {
+        systemPrompt,
+        systemPromptHash,
+        completedTurnsFingerprint,
+        turns,
+        userText,
+        agentKey: normalizedAgentKey,
+    });
 }
 /** Normalize OpenAI message content to a plain string. */
 function textContent(content) {
@@ -589,8 +647,6 @@ function textContent(content) {
 }
 function parseMessages(messages) {
     let systemPrompt = "You are a helpful assistant.";
-    const pairs = [];
-    const toolResults = [];
     // Collect system messages
     const systemParts = messages
         .filter((m) => m.role === "system")
@@ -598,40 +654,184 @@ function parseMessages(messages) {
     if (systemParts.length > 0) {
         systemPrompt = systemParts.join("\n");
     }
-    // Separate tool results from conversation turns
     const nonSystem = messages.filter((m) => m.role !== "system");
-    let pendingUser = "";
+    const parsedTurns = [];
+    let currentTurn;
     for (const msg of nonSystem) {
-        if (msg.role === "tool") {
-            toolResults.push({
-                toolCallId: msg.tool_call_id ?? "",
-                content: textContent(msg.content),
-            });
+        if (msg.role === "user") {
+            if (currentTurn)
+                parsedTurns.push(currentTurn);
+            currentTurn = {
+                userText: textContent(msg.content),
+                segments: [],
+            };
+            continue;
         }
-        else if (msg.role === "user") {
-            if (pendingUser) {
-                pairs.push({ userText: pendingUser, assistantText: "" });
-            }
-            pendingUser = textContent(msg.content);
+        if (!currentTurn) {
+            currentTurn = { userText: "", segments: [] };
         }
-        else if (msg.role === "assistant") {
-            // Skip assistant messages that are just tool_calls with no text
+        if (msg.role === "assistant") {
             const text = textContent(msg.content);
-            if (pendingUser) {
-                pairs.push({ userText: pendingUser, assistantText: text });
-                pendingUser = "";
+            if (text) {
+                currentTurn.segments.push({ kind: "assistantText", text });
             }
+            if (msg.tool_calls?.length) {
+                currentTurn.segments.push({
+                    kind: "assistantToolCalls",
+                    toolCalls: msg.tool_calls,
+                });
+            }
+            continue;
+        }
+        if (msg.role === "tool") {
+            currentTurn.segments.push({
+                kind: "toolResult",
+                result: {
+                    toolCallId: msg.tool_call_id ?? "",
+                    content: textContent(msg.content),
+                },
+            });
         }
     }
-    let lastUserText = "";
-    if (pendingUser) {
-        lastUserText = pendingUser;
+    if (currentTurn)
+        parsedTurns.push(currentTurn);
+    let userText = "";
+    let toolResults = [];
+    let pendingAssistantSummary = "";
+    let completedTurnStates = parsedTurns;
+    const lastTurn = parsedTurns.at(-1);
+    if (lastTurn) {
+        const trailingSegments = splitTrailingToolResults(lastTurn.segments);
+        const hasAssistantSummary = trailingSegments.base.length > 0;
+        if (trailingSegments.trailing.length > 0 && hasAssistantSummary) {
+            completedTurnStates = parsedTurns.slice(0, -1);
+            userText = lastTurn.userText;
+            toolResults = trailingSegments.trailing.map((segment) => segment.result);
+            pendingAssistantSummary = summarizeTurnSegments(trailingSegments.base);
+        }
+        else if (lastTurn.userText && lastTurn.segments.length === 0) {
+            completedTurnStates = parsedTurns.slice(0, -1);
+            userText = lastTurn.userText;
+        }
     }
-    else if (pairs.length > 0 && toolResults.length === 0) {
-        const last = pairs.pop();
-        lastUserText = last.userText;
+    const turns = completedTurnStates
+        .map((turn) => ({
+        userText: turn.userText,
+        assistantText: summarizeTurnSegments(turn.segments),
+    }))
+        .filter((turn) => turn.userText || turn.assistantText);
+    return {
+        systemPrompt,
+        userText,
+        turns,
+        toolResults,
+        pendingAssistantSummary,
+        completedTurnsFingerprint: buildCompletedTurnsFingerprint(systemPrompt, turns),
+    };
+}
+function splitTrailingToolResults(segments) {
+    let index = segments.length;
+    while (index > 0 && segments[index - 1]?.kind === "toolResult") {
+        index -= 1;
     }
-    return { systemPrompt, userText: lastUserText, turns: pairs, toolResults };
+    return {
+        base: segments.slice(0, index),
+        trailing: segments.slice(index).filter((segment) => segment.kind === "toolResult"),
+    };
+}
+function summarizeTurnSegments(segments) {
+    const parts = [];
+    for (const segment of segments) {
+        if (segment.kind === "assistantText") {
+            const trimmed = segment.text.trim();
+            if (trimmed)
+                parts.push(trimmed);
+            continue;
+        }
+        if (segment.kind === "assistantToolCalls") {
+            const summary = segment.toolCalls.map(formatToolCallSummary).join("\n\n");
+            if (summary)
+                parts.push(summary);
+            continue;
+        }
+        parts.push(formatToolResultSummary(segment.result));
+    }
+    return parts.join("\n\n").trim();
+}
+function formatToolCallSummary(call) {
+    const args = call.function.arguments?.trim();
+    return args
+        ? `[assistant requested tool ${call.function.name} id=${call.id}]\n${args}`
+        : `[assistant requested tool ${call.function.name} id=${call.id}]`;
+}
+function formatToolResultSummary(result) {
+    const label = result.toolCallId
+        ? `[tool result id=${result.toolCallId}]`
+        : "[tool result]";
+    const content = result.content.trim();
+    return content ? `${label}\n${content}` : label;
+}
+function buildCompletedTurnsFingerprint(systemPrompt, turns) {
+    return hashString(JSON.stringify({ systemPrompt, turns }));
+}
+function buildToolResumePrompt(userText, pendingAssistantSummary, toolResults) {
+    const parts = [userText.trim()];
+    if (pendingAssistantSummary.trim()) {
+        parts.push(`[previous assistant tool activity]\n${pendingAssistantSummary.trim()}`);
+    }
+    if (toolResults.length > 0) {
+        parts.push(toolResults.map(formatToolResultSummary).join("\n\n"));
+    }
+    return parts.filter(Boolean).join("\n\n");
+}
+function buildInitialHandoffPrompt(userText, turns, pendingAssistantSummary, toolResults) {
+    const transcript = turns.map((turn, index) => {
+        const sections = [`Turn ${index + 1}`];
+        if (turn.userText.trim())
+            sections.push(`User: ${turn.userText.trim()}`);
+        if (turn.assistantText.trim())
+            sections.push(`Assistant: ${turn.assistantText.trim()}`);
+        return sections.join("\n");
+    });
+    const inProgress = buildToolResumePrompt("", pendingAssistantSummary, toolResults).trim();
+    const history = [
+        ...transcript,
+        ...(inProgress ? [`In-progress turn\n${inProgress}`] : []),
+    ].join("\n\n").trim();
+    if (!history)
+        return userText;
+    return [
+        "[OpenCode session handoff]",
+        "You are continuing an existing session that previously ran on another provider/model.",
+        "Treat the transcript below as prior conversation history before answering the latest user message.",
+        "",
+        "<previous-session-transcript>",
+        history,
+        "</previous-session-transcript>",
+        "",
+        "Latest user message:",
+        userText.trim(),
+    ].filter(Boolean).join("\n");
+}
+function buildTitleUserPrompt(systemPrompt, content) {
+    return [systemPrompt.trim(), content.trim()].filter(Boolean).join("\n\n");
+}
+function selectToolsForChoice(tools, toolChoice) {
+    if (!tools.length)
+        return [];
+    if (toolChoice === undefined || toolChoice === null || toolChoice === "auto" || toolChoice === "required") {
+        return tools;
+    }
+    if (toolChoice === "none") {
+        return [];
+    }
+    if (typeof toolChoice === "object") {
+        const choice = toolChoice;
+        if (choice.type === "function" && typeof choice.function?.name === "string") {
+            return tools.filter((tool) => tool.function.name === choice.function.name);
+        }
+    }
+    return tools;
 }
 /** Convert OpenAI tool definitions to Cursor's MCP tool protobuf format. */
 function buildMcpToolDefinitions(tools) {
@@ -774,6 +974,12 @@ function makeHeartbeatBytes() {
     });
     return toBinary(AgentClientMessageSchema, heartbeat);
 }
+function scheduleBridgeEnd(bridge) {
+    queueMicrotask(() => {
+        if (bridge.alive)
+            bridge.end();
+    });
+}
 /**
  * Create a stateful parser for Connect protocol frames.
  * Handles buffering partial data across chunks.
@@ -1086,40 +1292,56 @@ function sendExecResult(execMsg, messageCase, value, sendFrame) {
     });
     sendFrame(toBinary(AgentClientMessageSchema, clientMessage));
 }
-/** Derive a key for active bridge lookup (tool-call continuations). Model-specific. */
-function deriveBridgeKey(modelId, messages, requestScope) {
+/** Derive a key for active bridge lookup (tool-call continuations). */
+function deriveBridgeKey(modelId, messages, sessionId, agentKey) {
+    if (sessionId) {
+        const normalizedAgent = normalizeAgentKey(agentKey);
+        return createHash("sha256")
+            .update(`bridge:${sessionId}:${normalizedAgent}`)
+            .digest("hex")
+            .slice(0, 16);
+    }
     const firstUserMsg = messages.find((m) => m.role === "user");
     const firstUserText = firstUserMsg ? textContent(firstUserMsg.content) : "";
+    const normalizedAgent = normalizeAgentKey(agentKey);
     return createHash("sha256")
-        .update(`bridge:${requestScope.sessionID ?? ""}:${requestScope.agent ?? ""}:${modelId}:${firstUserText.slice(0, 200)}`)
+        .update(`bridge:${normalizedAgent}:${modelId}:${firstUserText.slice(0, 200)}`)
         .digest("hex")
         .slice(0, 16);
 }
 /** Derive a key for conversation state. Model-independent so context survives model switches. */
-function deriveConversationKey(messages, requestScope) {
-    if (requestScope.sessionID) {
-        const scope = shouldIsolateConversation(requestScope)
-            ? `${requestScope.sessionID}:${requestScope.agent ?? ""}:${requestScope.messageID ?? crypto.randomUUID()}`
-            : `${requestScope.sessionID}:${requestScope.agent ?? "default"}`;
+function deriveConversationKey(messages, sessionId, agentKey) {
+    if (sessionId) {
+        const normalizedAgent = normalizeAgentKey(agentKey);
         return createHash("sha256")
-            .update(`conv:${scope}`)
+            .update(`session:${sessionId}:${normalizedAgent}`)
             .digest("hex")
             .slice(0, 16);
     }
-    const firstUserMsg = messages.find((m) => m.role === "user");
-    const firstUserText = firstUserMsg ? textContent(firstUserMsg.content) : "";
     return createHash("sha256")
-        .update(`conv:${firstUserText.slice(0, 200)}`)
+        .update(`${normalizeAgentKey(agentKey)}:${buildConversationFingerprint(messages)}`)
         .digest("hex")
         .slice(0, 16);
 }
-function shouldIsolateConversation(requestScope) {
-    return Boolean(requestScope.agent
-        && EPHEMERAL_CURSOR_AGENTS.has(requestScope.agent)
-        && requestScope.messageID);
+function buildConversationFingerprint(messages) {
+    return messages.map((message) => {
+        const toolCallIDs = (message.tool_calls ?? []).map((call) => call.id).join(",");
+        return `${message.role}:${textContent(message.content)}:${message.tool_call_id ?? ""}:${toolCallIDs}`;
+    }).join("\n---\n");
+}
+function updateStoredConversationAfterCompletion(convKey, metadata, assistantText) {
+    const stored = conversationStates.get(convKey);
+    if (!stored)
+        return;
+    const nextTurns = metadata.userText
+        ? [...metadata.turns, { userText: metadata.userText, assistantText: assistantText.trim() }]
+        : metadata.turns;
+    stored.systemPromptHash = metadata.systemPromptHash;
+    stored.completedTurnsFingerprint = buildCompletedTurnsFingerprint(metadata.systemPrompt, nextTurns);
+    stored.lastAccessMs = Date.now();
 }
 /** Create an SSE streaming Response that reads from a live bridge. */
-function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools, modelId, bridgeKey, convKey) {
+function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools, modelId, bridgeKey, convKey, metadata) {
     const completionId = `chatcmpl-${crypto.randomUUID().replace(/-/g, "").slice(0, 28)}`;
     const created = Math.floor(Date.now() / 1000);
     const stream = new ReadableStream({
@@ -1167,6 +1389,7 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools,
                 totalTokens: 0,
             };
             const tagFilter = createThinkingTagFilter();
+            let assistantText = metadata.assistantSeedText ?? "";
             let mcpExecReceived = false;
             let endStreamError = null;
             const processChunk = createConnectFrameParser((messageBytes) => {
@@ -1180,8 +1403,10 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools,
                             const { content, reasoning } = tagFilter.process(text);
                             if (reasoning)
                                 sendSSE(makeChunk({ reasoning_content: reasoning }));
-                            if (content)
+                            if (content) {
+                                assistantText += content;
                                 sendSSE(makeChunk({ content }));
+                            }
                         }
                     }, 
                     // onMcpExec — the model wants to execute a tool.
@@ -1191,8 +1416,21 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools,
                         const flushed = tagFilter.flush();
                         if (flushed.reasoning)
                             sendSSE(makeChunk({ reasoning_content: flushed.reasoning }));
-                        if (flushed.content)
+                        if (flushed.content) {
+                            assistantText += flushed.content;
                             sendSSE(makeChunk({ content: flushed.content }));
+                        }
+                        const assistantSeedText = [
+                            assistantText.trim(),
+                            formatToolCallSummary({
+                                id: exec.toolCallId,
+                                type: "function",
+                                function: {
+                                    name: exec.toolName,
+                                    arguments: exec.decodedArgs,
+                                },
+                            }),
+                        ].filter(Boolean).join("\n\n");
                         const toolCallIndex = state.toolCallIndex++;
                         sendSSE(makeChunk({
                             tool_calls: [{
@@ -1212,6 +1450,11 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools,
                             blobStore,
                             mcpTools,
                             pendingExecs: state.pendingExecs,
+                            modelId,
+                            metadata: {
+                                ...metadata,
+                                assistantSeedText,
+                            },
                         });
                         sendSSE(makeChunk({}, "tool_calls"));
                         sendDone();
@@ -1237,6 +1480,7 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools,
                         ...errorDetails(endStreamError),
                     });
                 }
+                scheduleBridgeEnd(bridge);
             });
             bridge.onData(processChunk);
             bridge.onClose((code) => {
@@ -1259,23 +1503,27 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools,
                     const flushed = tagFilter.flush();
                     if (flushed.reasoning)
                         sendSSE(makeChunk({ reasoning_content: flushed.reasoning }));
-                    if (flushed.content)
+                    if (flushed.content) {
+                        assistantText += flushed.content;
                         sendSSE(makeChunk({ content: flushed.content }));
+                    }
+                    updateStoredConversationAfterCompletion(convKey, metadata, assistantText);
                     sendSSE(makeChunk({}, "stop"));
                     sendSSE(makeUsageChunk());
                     sendDone();
                     closeController();
                 }
-                else if (code !== 0) {
-                    // Bridge died while tool calls are pending (timeout, crash, etc.).
-                    // Close the SSE stream so the client doesn't hang forever.
-                    sendSSE(makeChunk({ content: "\n[Error: bridge connection lost]" }));
-                    sendSSE(makeChunk({}, "stop"));
-                    sendSSE(makeUsageChunk());
-                    sendDone();
-                    closeController();
-                    // Remove stale entry so the next request doesn't try to resume it.
+                else {
                     activeBridges.delete(bridgeKey);
+                    if (code !== 0 && !closed) {
+                        // Bridge died while tool calls are pending (timeout, crash, etc.).
+                        // Close the SSE stream so the client doesn't hang forever.
+                        sendSSE(makeChunk({ content: "\n[Error: bridge connection lost]" }));
+                        sendSSE(makeChunk({}, "stop"));
+                        sendSSE(makeUsageChunk());
+                        sendDone();
+                        closeController();
+                    }
                 }
             });
         },
@@ -1293,13 +1541,20 @@ async function startBridge(accessToken, requestBytes) {
     const heartbeatTimer = setInterval(() => bridge.write(makeHeartbeatBytes()), 5_000);
     return { bridge, heartbeatTimer };
 }
-async function handleStreamingResponse(payload, accessToken, modelId, bridgeKey, convKey) {
+async function handleStreamingResponse(payload, accessToken, modelId, bridgeKey, convKey, metadata) {
     const { bridge, heartbeatTimer } = await startBridge(accessToken, payload.requestBytes);
-    return createBridgeStreamResponse(bridge, heartbeatTimer, payload.blobStore, payload.mcpTools, modelId, bridgeKey, convKey);
+    return createBridgeStreamResponse(bridge, heartbeatTimer, payload.blobStore, payload.mcpTools, modelId, bridgeKey, convKey, metadata);
 }
 /** Resume a paused bridge by sending MCP results and continuing to stream. */
-function handleToolResultResume(active, toolResults, modelId, bridgeKey, convKey) {
-    const { bridge, heartbeatTimer, blobStore, mcpTools, pendingExecs } = active;
+function handleToolResultResume(active, toolResults, bridgeKey, convKey) {
+    const { bridge, heartbeatTimer, blobStore, mcpTools, pendingExecs, modelId, metadata } = active;
+    const resumeMetadata = {
+        ...metadata,
+        assistantSeedText: [
+            metadata.assistantSeedText?.trim() ?? "",
+            toolResults.map(formatToolResultSummary).join("\n\n"),
+        ].filter(Boolean).join("\n\n"),
+    };
     // Send mcpResult for each pending exec that has a matching tool result
     for (const exec of pendingExecs) {
         const result = toolResults.find((r) => r.toolCallId === exec.toolCallId);
@@ -1339,12 +1594,15 @@ function handleToolResultResume(active, toolResults, modelId, bridgeKey, convKey
         });
         bridge.write(toBinary(AgentClientMessageSchema, clientMessage));
     }
-    return createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools, modelId, bridgeKey, convKey);
+    return createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools, modelId, bridgeKey, convKey, resumeMetadata);
 }
-async function handleNonStreamingResponse(payload, accessToken, modelId, convKey) {
+async function handleNonStreamingResponse(payload, accessToken, modelId, convKey, metadata) {
     const completionId = `chatcmpl-${crypto.randomUUID().replace(/-/g, "").slice(0, 28)}`;
     const created = Math.floor(Date.now() / 1000);
-    const { text, usage } = await collectFullResponse(payload, accessToken, modelId, convKey);
+    const { text, usage, finishReason, toolCalls } = await collectFullResponse(payload, accessToken, modelId, convKey, metadata);
+    const message = finishReason === "tool_calls"
+        ? { role: "assistant", content: null, tool_calls: toolCalls }
+        : { role: "assistant", content: text };
     return new Response(JSON.stringify({
         id: completionId,
         object: "chat.completion",
@@ -1353,17 +1611,18 @@ async function handleNonStreamingResponse(payload, accessToken, modelId, convKey
         choices: [
             {
                 index: 0,
-                message: { role: "assistant", content: text },
-                finish_reason: "stop",
+                message,
+                finish_reason: finishReason,
             },
         ],
         usage,
     }), { headers: { "Content-Type": "application/json" } });
 }
-async function collectFullResponse(payload, accessToken, modelId, convKey) {
+async function collectFullResponse(payload, accessToken, modelId, convKey, metadata) {
     const { promise, resolve, reject } = Promise.withResolvers();
     let fullText = "";
     let endStreamError = null;
+    const pendingToolCalls = [];
     const { bridge, heartbeatTimer } = await startBridge(accessToken, payload.requestBytes);
     const state = {
         toolCallIndex: 0,
@@ -1380,7 +1639,17 @@ async function collectFullResponse(payload, accessToken, modelId, convKey) {
                     return;
                 const { content } = tagFilter.process(text);
                 fullText += content;
-            }, () => { }, (checkpointBytes) => {
+            }, (exec) => {
+                pendingToolCalls.push({
+                    id: exec.toolCallId,
+                    type: "function",
+                    function: {
+                        name: exec.toolName,
+                        arguments: exec.decodedArgs,
+                    },
+                });
+                scheduleBridgeEnd(bridge);
+            }, (checkpointBytes) => {
                 const stored = conversationStates.get(convKey);
                 if (stored) {
                     stored.checkpoint = checkpointBytes;
@@ -1400,6 +1669,7 @@ async function collectFullResponse(payload, accessToken, modelId, convKey) {
                 ...errorDetails(endStreamError),
             });
         }
+        scheduleBridgeEnd(bridge);
     }));
     bridge.onClose(() => {
         clearInterval(heartbeatTimer);
@@ -1415,10 +1685,15 @@ async function collectFullResponse(payload, accessToken, modelId, convKey) {
             reject(endStreamError);
             return;
         }
+        if (pendingToolCalls.length === 0) {
+            updateStoredConversationAfterCompletion(convKey, metadata, fullText);
+        }
         const usage = computeUsage(state);
         resolve({
             text: fullText,
             usage,
+            finishReason: pendingToolCalls.length > 0 ? "tool_calls" : "stop",
+            toolCalls: pendingToolCalls,
         });
     });
     return promise;

package/package.json

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