@playwo/opencode-cursor-oauth 0.0.0-dev.1b946f85e9b0 → 0.0.0-dev.9b39a4eb497b

package/README.md

@@ -1,103 +1,31 @@
-# @playwo/opencode-cursor-oauth
+# opencode-cursor-oauth
 
-OpenCode plugin that connects to Cursor's API, giving you access to Cursor
-models inside OpenCode with full tool-calling support.
+Use Cursor models (Claude, GPT, Gemini, etc.) inside [OpenCode](https://opencode.ai).
 
-## Install in OpenCode
+## What it does
 
-Add this to `~/.config/opencode/opencode.json`:
+- **OAuth login** to Cursor via browser
+- **Model discovery** — automatically fetches your available Cursor models
+- **Local proxy** — runs an OpenAI-compatible endpoint that translates to Cursor's gRPC protocol
+- **Auto-refresh** — handles token expiration automatically
 
-```jsonc
-{
-  "$schema": "https://opencode.ai/config.json",
-  "plugin": [
-    "@playwo/opencode-cursor-oauth"
-  ],
-  "provider": {
-    "cursor": {
-      "name": "Cursor"
-    }
-  }
-}
-```
-
-The `cursor` provider stub is required because OpenCode drops providers that do
-not already exist in its bundled provider catalog.
-
-OpenCode installs npm plugins automatically at startup, so users do not need to
-clone this repository.
-
-## Authenticate
-
-```sh
-opencode auth login --provider cursor
-```
-
-This opens Cursor OAuth in the browser. Tokens are stored in
-`~/.local/share/opencode/auth.json` and refreshed automatically.
-
-## Use
-
-Start OpenCode and select any Cursor model. The plugin starts a local
-OpenAI-compatible proxy on demand and routes requests through Cursor's gRPC API.
-
-## How it works
-
-1. OAuth — browser-based login to Cursor via PKCE.
-2. Model discovery — queries Cursor's gRPC API for all available models; if discovery fails, the plugin disables the Cursor provider for that load and shows a visible error toast instead of crashing OpenCode.
-3. Local proxy — translates `POST /v1/chat/completions` into Cursor's
-   protobuf/Connect protocol.
-4. Native tool routing — rejects Cursor's built-in filesystem/shell tools and
-   exposes OpenCode's tool surface via Cursor MCP instead.
-
-Cursor agent streaming uses Cursor's `RunSSE` + `BidiAppend` transport, so the
-plugin runs entirely inside OpenCode without a Node sidecar.
+## Install
 
-## Architecture
+Add to your `opencode.json`:
 
+```json
+{
+  "plugin": ["@playwo/opencode-cursor-oauth"]
+}
 ```
-OpenCode  -->  /v1/chat/completions  -->  Bun.serve (proxy)
-                                              |
-                              RunSSE stream + BidiAppend writes
-                                              |
-                                Cursor Connect/SSE transport
-                                              |
-                                     api2.cursor.sh gRPC
-```
-
-### Tool call flow
-
-```
-1. Cursor model receives OpenAI tools via RequestContext (as MCP tool defs)
-2. Model tries native tools (readArgs, shellArgs, etc.)
-3. Proxy rejects each with typed error (ReadRejected, ShellRejected, etc.)
-4. Model falls back to MCP tool -> mcpArgs exec message
-5. Proxy emits OpenAI tool_calls SSE chunk, pauses the Cursor stream
-6. OpenCode executes tool, sends result in follow-up request
-7. Proxy resumes the Cursor stream with mcpResult and continues streaming
-```
-
-## Develop locally
-
-```sh
-bun install
-bun run build
-bun test/smoke.ts
-```
-
-## Publish
 
-GitHub Actions publishes this package with `.github/workflows/publish-npm.yml`.
+Then authenticate via the OpenCode UI (Settings → Providers → Cursor → Login).
 
-- branch pushes publish a `dev` build as `0.0.0-dev.<sha>`
-- versioned releases publish `latest` using the `package.json` version and upload the packed `.tgz` to the GitHub release
-
-Repository secrets required:
+## Requirements
 
-- `NPM_TOKEN` for npm publish access
+- Cursor account with API access
+- OpenCode 1.2+
 
-## Requirements
+## License
 
-- [OpenCode](https://opencode.ai)
-- [Bun](https://bun.sh)
-- Active [Cursor](https://cursor.com) subscription
+MIT

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 { startProxy, stopProxy } from "./proxy";
+import { startProxy, stopProxy, } from "./proxy";
 const CURSOR_PROVIDER_ID = "cursor";
 let lastModelDiscoveryError = null;
 /**
@@ -128,6 +128,15 @@ 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;
+            }
+        },
     };
 };
 function buildCursorProviderModels(models, port) {

package/dist/proxy.js

@@ -41,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);
@@ -471,7 +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);
+                    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);
@@ -509,10 +538,15 @@ export function stopProxy() {
     activeBridges.clear();
     conversationStates.clear();
 }
-function handleChatCompletion(body, accessToken) {
-    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: {
@@ -521,16 +555,24 @@ function handleChatCompletion(body, accessToken) {
             },
         }), { 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);
-    const convKey = deriveConversationKey(body.messages);
+    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.
@@ -545,28 +587,52 @@ function handleChatCompletion(body, accessToken) {
     }
     let stored = conversationStates.get(convKey);
     if (!stored) {
-        stored = {
-            conversationId: deterministicConversationId(convKey),
-            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) {
@@ -581,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")
@@ -590,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),
+                },
+            });
+        }
+    }
+    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;
+        }
+    }
+    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 {
+        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));
     }
-    let lastUserText = "";
-    if (pendingUser) {
-        lastUserText = pendingUser;
+    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()}`);
     }
-    else if (pairs.length > 0 && toolResults.length === 0) {
-        const last = pairs.pop();
-        lastUserText = last.userText;
+    if (toolResults.length > 0) {
+        parts.push(toolResults.map(formatToolResultSummary).join("\n\n"));
     }
-    return { systemPrompt, userText: lastUserText, turns: pairs, toolResults };
+    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) {
@@ -766,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.
@@ -908,6 +1122,12 @@ function handleKvMessage(kvMsg, blobStore, sendFrame) {
         const blobId = kvMsg.message.value.blobId;
         const blobIdKey = Buffer.from(blobId).toString("hex");
         const blobData = blobStore.get(blobIdKey);
+        if (!blobData) {
+            logPluginWarn("Cursor requested missing blob", {
+                blobId: blobIdKey,
+                knownBlobCount: blobStore.size,
+            });
+        }
         sendKvResponse(kvMsg, "getBlobResult", create(GetBlobResultSchema, blobData ? { blobData } : {}), sendFrame);
     }
     else if (kvCase === "setBlobArgs") {
@@ -1072,42 +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) {
+/** 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:${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) {
-    const firstUserMsg = messages.find((m) => m.role === "user");
-    const firstUserText = firstUserMsg ? textContent(firstUserMsg.content) : "";
+function deriveConversationKey(messages, sessionId, agentKey) {
+    if (sessionId) {
+        const normalizedAgent = normalizeAgentKey(agentKey);
+        return createHash("sha256")
+            .update(`session:${sessionId}:${normalizedAgent}`)
+            .digest("hex")
+            .slice(0, 16);
+    }
     return createHash("sha256")
-        .update(`conv:${firstUserText.slice(0, 200)}`)
+        .update(`${normalizeAgentKey(agentKey)}:${buildConversationFingerprint(messages)}`)
         .digest("hex")
         .slice(0, 16);
 }
-/** Deterministic UUID derived from convKey so Cursor's server-side conversation
- *  persists across proxy restarts. Formats 16 bytes of SHA-256 as a v4-shaped UUID. */
-function deterministicConversationId(convKey) {
-    const hex = createHash("sha256")
-        .update(`cursor-conv-id:${convKey}`)
-        .digest("hex")
-        .slice(0, 32);
-    // Format as UUID: xxxxxxxx-xxxx-4xxx-Nxxx-xxxxxxxxxxxx
-    return [
-        hex.slice(0, 8),
-        hex.slice(8, 12),
-        `4${hex.slice(13, 16)}`,
-        `${(0x8 | (parseInt(hex[16], 16) & 0x3)).toString(16)}${hex.slice(17, 20)}`,
-        hex.slice(20, 32),
-    ].join("-");
+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({
@@ -1155,7 +1389,9 @@ 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) => {
                 try {
                     const serverMessage = fromBinary(AgentServerMessageSchema, messageBytes);
@@ -1167,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.
@@ -1178,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: [{
@@ -1199,6 +1450,11 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools,
                             blobStore,
                             mcpTools,
                             pendingExecs: state.pendingExecs,
+                            modelId,
+                            metadata: {
+                                ...metadata,
+                                assistantSeedText,
+                            },
                         });
                         sendSSE(makeChunk({}, "tool_calls"));
                         sendDone();
@@ -1215,10 +1471,16 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools,
                     // Skip unparseable messages
                 }
             }, (endStreamBytes) => {
-                const endError = parseConnectEndStream(endStreamBytes);
-                if (endError) {
-                    sendSSE(makeChunk({ content: `\n[Error: ${endError.message}]` }));
+                endStreamError = parseConnectEndStream(endStreamBytes);
+                if (endStreamError) {
+                    logPluginError("Cursor stream returned Connect end-stream error", {
+                        modelId,
+                        bridgeKey,
+                        convKey,
+                        ...errorDetails(endStreamError),
+                    });
                 }
+                scheduleBridgeEnd(bridge);
             });
             bridge.onData(processChunk);
             bridge.onClose((code) => {
@@ -1229,27 +1491,39 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools,
                         stored.blobStore.set(k, v);
                     stored.lastAccessMs = Date.now();
                 }
+                if (endStreamError) {
+                    activeBridges.delete(bridgeKey);
+                    if (!closed) {
+                        closed = true;
+                        controller.error(endStreamError);
+                    }
+                    return;
+                }
                 if (!mcpExecReceived) {
                     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();
+                    }
                 }
             });
         },
@@ -1267,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);
@@ -1313,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, 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",
@@ -1327,16 +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, convKey) {
-    const { promise, resolve } = Promise.withResolvers();
+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,
@@ -1353,7 +1639,17 @@ async function collectFullResponse(payload, accessToken, 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;
@@ -1364,7 +1660,17 @@ async function collectFullResponse(payload, accessToken, convKey) {
         catch {
             // Skip
         }
-    }, () => { }));
+    }, (endStreamBytes) => {
+        endStreamError = parseConnectEndStream(endStreamBytes);
+        if (endStreamError) {
+            logPluginError("Cursor non-streaming response returned Connect end-stream error", {
+                modelId,
+                convKey,
+                ...errorDetails(endStreamError),
+            });
+        }
+        scheduleBridgeEnd(bridge);
+    }));
     bridge.onClose(() => {
         clearInterval(heartbeatTimer);
         const stored = conversationStates.get(convKey);
@@ -1375,10 +1681,19 @@ async function collectFullResponse(payload, accessToken, convKey) {
         }
         const flushed = tagFilter.flush();
         fullText += flushed.content;
+        if (endStreamError) {
+            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.1b946f85e9b0",
+  "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",