@playwo/opencode-cursor-oauth 0.0.9 → 0.2.0

package/dist/proxy.js

@@ -14,11 +14,15 @@
  */
 import { create, fromBinary, fromJson, toBinary, toJson } from "@bufbuild/protobuf";
 import { ValueSchema } from "@bufbuild/protobuf/wkt";
-import { AgentClientMessageSchema, AgentRunRequestSchema, AgentServerMessageSchema, BidiRequestIdSchema, ClientHeartbeatSchema, ConversationActionSchema, ConversationStateStructureSchema, ConversationStepSchema, AgentConversationTurnStructureSchema, ConversationTurnStructureSchema, AssistantMessageSchema, BackgroundShellSpawnResultSchema, DeleteResultSchema, DeleteRejectedSchema, DiagnosticsResultSchema, ExecClientMessageSchema, FetchErrorSchema, FetchResultSchema, GetBlobResultSchema, GrepErrorSchema, GrepResultSchema, KvClientMessageSchema, LsRejectedSchema, LsResultSchema, McpErrorSchema, McpResultSchema, McpSuccessSchema, McpTextContentSchema, McpToolDefinitionSchema, McpToolResultContentItemSchema, ModelDetailsSchema, ReadRejectedSchema, ReadResultSchema, RequestContextResultSchema, RequestContextSchema, RequestContextSuccessSchema, SetBlobResultSchema, ShellRejectedSchema, ShellResultSchema, UserMessageActionSchema, UserMessageSchema, WriteRejectedSchema, WriteResultSchema, WriteShellStdinErrorSchema, WriteShellStdinResultSchema, } from "./proto/agent_pb";
+import { AgentClientMessageSchema, AgentRunRequestSchema, AgentServerMessageSchema, BidiRequestIdSchema, ClientHeartbeatSchema, ConversationActionSchema, ConversationStateStructureSchema, ConversationStepSchema, AgentConversationTurnStructureSchema, ConversationTurnStructureSchema, AssistantMessageSchema, BackgroundShellSpawnResultSchema, DeleteResultSchema, DeleteRejectedSchema, DiagnosticsResultSchema, ExecClientMessageSchema, FetchErrorSchema, FetchResultSchema, GetBlobResultSchema, GrepErrorSchema, GrepResultSchema, KvClientMessageSchema, LsRejectedSchema, LsResultSchema, McpErrorSchema, McpResultSchema, McpSuccessSchema, McpTextContentSchema, McpToolDefinitionSchema, McpToolResultContentItemSchema, ModelDetailsSchema, NameAgentRequestSchema, NameAgentResponseSchema, ReadRejectedSchema, ReadResultSchema, RequestContextResultSchema, RequestContextSchema, RequestContextSuccessSchema, SetBlobResultSchema, ShellRejectedSchema, ShellResultSchema, UserMessageActionSchema, UserMessageSchema, WriteRejectedSchema, WriteResultSchema, WriteShellStdinErrorSchema, WriteShellStdinResultSchema, } from "./proto/agent_pb";
 import { createHash } from "node:crypto";
+import { connect as connectHttp2 } from "node:http2";
+import { errorDetails, logPluginError, logPluginWarn } from "./logger";
 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;
+const OPENCODE_TITLE_REQUEST_MARKER = "Generate a title for this conversation:";
 const SSE_HEADERS = {
     "Content-Type": "text/event-stream",
     "Cache-Control": "no-cache",
@@ -38,6 +42,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);
@@ -46,19 +75,40 @@ function frameConnectMessage(data, flags = 0) {
     frame.set(data, 5);
     return frame;
 }
+function decodeConnectUnaryBody(payload) {
+    if (payload.length < 5)
+        return null;
+    let offset = 0;
+    while (offset + 5 <= payload.length) {
+        const flags = payload[offset];
+        const view = new DataView(payload.buffer, payload.byteOffset + offset, payload.byteLength - offset);
+        const messageLength = view.getUint32(1, false);
+        const frameEnd = offset + 5 + messageLength;
+        if (frameEnd > payload.length)
+            return null;
+        if ((flags & 0b0000_0001) !== 0)
+            return null;
+        if ((flags & CONNECT_END_STREAM_FLAG) === 0) {
+            return payload.subarray(offset + 5, frameEnd);
+        }
+        offset = frameEnd;
+    }
+    return null;
+}
 function buildCursorHeaders(options, contentType, extra = {}) {
-    const headers = new Headers({
+    const headers = new Headers(buildCursorHeaderValues(options, contentType, extra));
+    return headers;
+}
+function buildCursorHeaderValues(options, contentType, extra = {}) {
+    return {
         authorization: `Bearer ${options.accessToken}`,
         "content-type": contentType,
         "x-ghost-mode": "true",
         "x-cursor-client-version": CURSOR_CLIENT_VERSION,
         "x-cursor-client-type": "cli",
         "x-request-id": crypto.randomUUID(),
-    });
-    for (const [key, value] of Object.entries(extra)) {
-        headers.set(key, value);
-    }
-    return headers;
+        ...extra,
+    };
 }
 function encodeVarint(value) {
     if (!Number.isSafeInteger(value) || value < 0) {
@@ -130,6 +180,11 @@ async function createCursorSession(options) {
     });
     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}` : ""}`);
     }
     const cbs = {
@@ -160,6 +215,12 @@ async function createCursorSession(options) {
         });
         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);
@@ -183,7 +244,11 @@ async function createCursorSession(options) {
                 }
             }
         }
-        catch {
+        catch (error) {
+            logPluginWarn("Cursor stream reader closed with error", {
+                requestId: options.requestId,
+                ...errorDetails(error),
+            });
             finish(alive ? 1 : closeCode);
         }
     })();
@@ -196,7 +261,11 @@ async function createCursorSession(options) {
                 return;
             writeChain = writeChain
                 .then(() => append(data))
-                .catch(() => {
+                .catch((error) => {
+                logPluginError("Cursor stream append failed", {
+                    requestId: options.requestId,
+                    ...errorDetails(error),
+                });
                 try {
                     abortController.abort();
                 }
@@ -236,6 +305,17 @@ async function createCursorSession(options) {
     };
 }
 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();
@@ -246,9 +326,13 @@ export async function callCursorUnaryRpc(options) {
         }, timeoutMs)
         : undefined;
     try {
-        const response = await fetch(new URL(options.rpcPath, options.url ?? CURSOR_API_URL), {
+        const response = await fetch(target, {
             method: "POST",
-            headers: buildCursorHeaders(options, "application/proto"),
+            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,
         });
@@ -260,6 +344,12 @@ export async function callCursorUnaryRpc(options) {
         };
     }
     catch {
+        logPluginError("Cursor unary fetch transport failed", {
+            rpcPath: options.rpcPath,
+            url: target.toString(),
+            timeoutMs,
+            timedOut,
+        });
         return {
             body: new Uint8Array(),
             exitCode: timedOut ? 124 : 1,
@@ -271,6 +361,121 @@ export async function callCursorUnaryRpc(options) {
             clearTimeout(timeout);
     }
 }
+async function callCursorUnaryRpcOverHttp2(options, target) {
+    const timeoutMs = options.timeoutMs ?? 5_000;
+    const authority = `${target.protocol}//${target.host}`;
+    return new Promise((resolve) => {
+        let settled = false;
+        let timedOut = false;
+        let session;
+        let stream;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timeout)
+                clearTimeout(timeout);
+            try {
+                stream?.close();
+            }
+            catch { }
+            try {
+                session?.close();
+            }
+            catch { }
+            resolve(result);
+        };
+        const timeout = timeoutMs > 0
+            ? setTimeout(() => {
+                timedOut = true;
+                finish({
+                    body: new Uint8Array(),
+                    exitCode: 124,
+                    timedOut: true,
+                });
+            }, timeoutMs)
+            : undefined;
+        try {
+            session = connectHttp2(authority);
+            session.once("error", (error) => {
+                logPluginError("Cursor unary HTTP/2 session failed", {
+                    rpcPath: options.rpcPath,
+                    url: target.toString(),
+                    timedOut,
+                    ...errorDetails(error),
+                });
+                finish({
+                    body: new Uint8Array(),
+                    exitCode: timedOut ? 124 : 1,
+                    timedOut,
+                });
+            });
+            const headers = {
+                ":method": "POST",
+                ":path": `${target.pathname}${target.search}`,
+                ...buildCursorHeaderValues(options, "application/proto", {
+                    accept: "application/proto, application/json",
+                    "connect-protocol-version": CURSOR_CONNECT_PROTOCOL_VERSION,
+                    "connect-timeout-ms": String(timeoutMs),
+                }),
+            };
+            stream = session.request(headers);
+            let statusCode = 0;
+            const chunks = [];
+            stream.once("response", (responseHeaders) => {
+                const statusHeader = responseHeaders[":status"];
+                statusCode = typeof statusHeader === "number"
+                    ? statusHeader
+                    : Number(statusHeader ?? 0);
+            });
+            stream.on("data", (chunk) => {
+                chunks.push(Buffer.from(chunk));
+            });
+            stream.once("end", () => {
+                const body = new Uint8Array(Buffer.concat(chunks));
+                finish({
+                    body,
+                    exitCode: statusCode >= 200 && statusCode < 300 ? 0 : (statusCode || 1),
+                    timedOut,
+                });
+            });
+            stream.once("error", (error) => {
+                logPluginError("Cursor unary HTTP/2 stream failed", {
+                    rpcPath: options.rpcPath,
+                    url: target.toString(),
+                    timedOut,
+                    ...errorDetails(error),
+                });
+                finish({
+                    body: new Uint8Array(),
+                    exitCode: timedOut ? 124 : 1,
+                    timedOut,
+                });
+            });
+            // Bun's node:http2 client currently breaks on end(Buffer.alloc(0)) against
+            // Cursor's HTTPS endpoint, but a header-only end() succeeds for empty unary bodies.
+            if (options.requestBody.length > 0) {
+                stream.end(Buffer.from(options.requestBody));
+            }
+            else {
+                stream.end();
+            }
+        }
+        catch (error) {
+            logPluginError("Cursor unary HTTP/2 setup failed", {
+                rpcPath: options.rpcPath,
+                url: target.toString(),
+                timedOut,
+                ...errorDetails(error),
+            });
+            finish({
+                body: new Uint8Array(),
+                exitCode: timedOut ? 124 : 1,
+                timedOut,
+            });
+        }
+    });
+}
 let proxyServer;
 let proxyPort;
 let proxyAccessTokenProvider;
@@ -312,10 +517,19 @@ 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);
+                    logPluginError("Cursor proxy request failed", {
+                        path: url.pathname,
+                        method: req.method,
+                        ...errorDetails(err),
+                    });
                     return new Response(JSON.stringify({
                         error: { message, type: "server_error", code: "internal_error" },
                     }), { status: 500, headers: { "Content-Type": "application/json" } });
@@ -345,10 +559,26 @@ 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 titleDetection = detectTitleRequest(body);
+    const isTitleAgent = titleDetection.matched;
+    if (isTitleAgent) {
+        const titleSourceText = buildTitleSourceText(userText, turns, pendingAssistantSummary, toolResults);
+        if (!titleSourceText) {
+            return new Response(JSON.stringify({
+                error: {
+                    message: "No title source text found",
+                    type: "invalid_request_error",
+                },
+            }), { status: 400, headers: { "Content-Type": "application/json" } });
+        }
+        return handleTitleGenerationRequest(titleSourceText, accessToken, modelId, body.stream !== false);
+    }
+    const tools = selectToolsForChoice(body.tools ?? [], body.tool_choice);
     if (!userText && toolResults.length === 0) {
         return new Response(JSON.stringify({
             error: {
@@ -357,16 +587,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.
@@ -381,28 +619,49 @@ 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;
+    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) {
@@ -417,8 +676,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")
@@ -426,40 +683,212 @@ 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));
+    }
+    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 buildTitleSourceText(userText, turns, pendingAssistantSummary, toolResults) {
+    const history = turns
+        .map((turn) => [
+        isTitleRequestMarker(turn.userText) ? "" : turn.userText.trim(),
+        turn.assistantText.trim(),
+    ].filter(Boolean).join("\n"))
+        .filter(Boolean);
+    if (pendingAssistantSummary.trim()) {
+        history.push(pendingAssistantSummary.trim());
+    }
+    if (toolResults.length > 0) {
+        history.push(toolResults.map(formatToolResultSummary).join("\n\n"));
+    }
+    if (userText.trim() && !isTitleRequestMarker(userText)) {
+        history.push(userText.trim());
+    }
+    return history.join("\n\n").trim();
+}
+function detectTitleRequest(body) {
+    if ((body.tools?.length ?? 0) > 0) {
+        return { matched: false, reason: "tools-present" };
+    }
+    const firstNonSystem = body.messages.find((message) => message.role !== "system");
+    if (firstNonSystem?.role === "user" && isTitleRequestMarker(textContent(firstNonSystem.content))) {
+        return { matched: true, reason: "opencode-title-marker" };
     }
-    let lastUserText = "";
-    if (pendingUser) {
-        lastUserText = pendingUser;
+    return { matched: false, reason: "no-title-marker" };
+}
+function isTitleRequestMarker(text) {
+    return text.trim() === OPENCODE_TITLE_REQUEST_MARKER;
+}
+function selectToolsForChoice(tools, toolChoice) {
+    if (!tools.length)
+        return [];
+    if (toolChoice === undefined || toolChoice === null || toolChoice === "auto" || toolChoice === "required") {
+        return tools;
+    }
+    if (toolChoice === "none") {
+        return [];
     }
-    else if (pairs.length > 0 && toolResults.length === 0) {
-        const last = pairs.pop();
-        lastUserText = last.userText;
+    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 { systemPrompt, userText: lastUserText, turns: pairs, toolResults };
+    return tools;
 }
 /** Convert OpenAI tool definitions to Cursor's MCP tool protobuf format. */
 function buildMcpToolDefinitions(tools) {
@@ -602,6 +1031,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.
@@ -744,6 +1179,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") {
@@ -908,42 +1349,151 @@ 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();
+}
+function deriveFallbackTitle(text) {
+    const cleaned = text
+        .replace(/<[^>]+>/g, " ")
+        .replace(/\[[^\]]+\]/g, " ")
+        .replace(/[^\p{L}\p{N}'’\-\s]+/gu, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (!cleaned)
+        return "";
+    const words = cleaned.split(" ").filter(Boolean).slice(0, 6);
+    return finalizeTitle(words.map(titleCaseWord).join(" "));
+}
+function titleCaseWord(word) {
+    if (!word)
+        return word;
+    return word[0].toUpperCase() + word.slice(1);
+}
+function finalizeTitle(value) {
+    return value
+        .replace(/^#{1,6}\s*/, "")
+        .replace(/[.!?,:;]+$/g, "")
+        .replace(/\s+/g, " ")
+        .trim()
+        .slice(0, 80)
+        .trim();
+}
+function createBufferedSSETextResponse(modelId, text, usage) {
+    const completionId = `chatcmpl-${crypto.randomUUID().replace(/-/g, "").slice(0, 28)}`;
+    const created = Math.floor(Date.now() / 1000);
+    const payload = [
+        {
+            id: completionId,
+            object: "chat.completion.chunk",
+            created,
+            model: modelId,
+            choices: [{ index: 0, delta: { content: text }, finish_reason: null }],
+        },
+        {
+            id: completionId,
+            object: "chat.completion.chunk",
+            created,
+            model: modelId,
+            choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
+        },
+        {
+            id: completionId,
+            object: "chat.completion.chunk",
+            created,
+            model: modelId,
+            choices: [],
+            usage,
+        },
+    ].map((chunk) => `data: ${JSON.stringify(chunk)}\n\n`).join("") + "data: [DONE]\n\n";
+    return new Response(payload, { headers: SSE_HEADERS });
+}
+async function handleTitleGenerationRequest(sourceText, accessToken, modelId, stream) {
+    const requestBody = toBinary(NameAgentRequestSchema, create(NameAgentRequestSchema, {
+        userMessage: sourceText,
+    }));
+    const response = await callCursorUnaryRpc({
+        accessToken,
+        rpcPath: "/agent.v1.AgentService/NameAgent",
+        requestBody,
+        timeoutMs: 5_000,
+    });
+    if (response.timedOut) {
+        throw new Error("Cursor title generation timed out");
+    }
+    if (response.exitCode !== 0) {
+        throw new Error(`Cursor title generation failed with HTTP ${response.exitCode}`);
+    }
+    const payload = decodeConnectUnaryBody(response.body) ?? response.body;
+    const decoded = fromBinary(NameAgentResponseSchema, payload);
+    const title = finalizeTitle(decoded.name) || deriveFallbackTitle(sourceText) || "Untitled Session";
+    const usage = { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 };
+    if (stream) {
+        return createBufferedSSETextResponse(modelId, title, usage);
+    }
+    const completionId = `chatcmpl-${crypto.randomUUID().replace(/-/g, "").slice(0, 28)}`;
+    const created = Math.floor(Date.now() / 1000);
+    return new Response(JSON.stringify({
+        id: completionId,
+        object: "chat.completion",
+        created,
+        model: modelId,
+        choices: [
+            {
+                index: 0,
+                message: { role: "assistant", content: title },
+                finish_reason: "stop",
+            },
+        ],
+        usage,
+    }), { headers: { "Content-Type": "application/json" } });
 }
 /** 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({
@@ -991,7 +1541,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);
@@ -1003,8 +1555,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.
@@ -1014,8 +1568,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: [{
@@ -1035,6 +1602,11 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools,
                             blobStore,
                             mcpTools,
                             pendingExecs: state.pendingExecs,
+                            modelId,
+                            metadata: {
+                                ...metadata,
+                                assistantSeedText,
+                            },
                         });
                         sendSSE(makeChunk({}, "tool_calls"));
                         sendDone();
@@ -1051,10 +1623,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) => {
@@ -1065,27 +1643,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();
+                    }
                 }
             });
         },
@@ -1103,13 +1693,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);
@@ -1149,12 +1746,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",
@@ -1163,16 +1763,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,
@@ -1189,7 +1791,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;
@@ -1200,7 +1812,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);
@@ -1211,10 +1833,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;