@playwo/opencode-cursor-oauth 0.0.0-dev.c1bf17c092a2 → 0.0.0-dev.c1f285cb4d7e

package/dist/index.js

@@ -133,6 +133,9 @@ export const CursorAuthPlugin = async (input) => {
                 return;
             output.headers["x-opencode-session-id"] = incoming.sessionID;
             output.headers["x-session-id"] = incoming.sessionID;
+            if (incoming.agent) {
+                output.headers["x-opencode-agent"] = incoming.agent;
+            }
         },
     };
 };

package/dist/proxy.js

@@ -14,7 +14,7 @@
  */
 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";
@@ -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);
@@ -49,6 +74,26 @@ 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(buildCursorHeaderValues(options, contentType, extra));
     return headers;
@@ -474,7 +519,8 @@ export async function startProxy(getAccessToken, models = []) {
                     const sessionId = req.headers.get("x-opencode-session-id")
                         ?? req.headers.get("x-session-id")
                         ?? undefined;
-                    return handleChatCompletion(body, accessToken, { sessionId });
+                    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);
@@ -513,9 +559,24 @@ export function stopProxy() {
     conversationStates.clear();
 }
 function handleChatCompletion(body, accessToken, context = {}) {
-    const { systemPrompt, userText, turns, toolResults } = parseMessages(body.messages);
+    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";
+    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: {
@@ -524,16 +585,24 @@ function handleChatCompletion(body, accessToken, context = {}) {
             },
         }), { 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, context.sessionId);
-    const convKey = deriveConversationKey(body.messages, context.sessionId);
+    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.
@@ -548,28 +617,49 @@ function handleChatCompletion(body, accessToken, context = {}) {
     }
     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;
+    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) {
@@ -584,8 +674,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")
@@ -593,40 +681,194 @@ 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) => [turn.userText.trim(), turn.assistantText.trim()].filter(Boolean).join("\n")).filter(Boolean);
+    if (pendingAssistantSummary.trim()) {
+        history.push(pendingAssistantSummary.trim());
     }
-    let lastUserText = "";
-    if (pendingUser) {
-        lastUserText = pendingUser;
+    if (toolResults.length > 0) {
+        history.push(toolResults.map(formatToolResultSummary).join("\n\n"));
     }
-    else if (pairs.length > 0 && toolResults.length === 0) {
-        const last = pairs.pop();
-        lastUserText = last.userText;
+    if (userText.trim()) {
+        history.push(userText.trim());
+    }
+    return history.join("\n\n").trim();
+}
+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 { systemPrompt, userText: lastUserText, turns: pairs, toolResults };
+    return tools;
 }
 /** Convert OpenAI tool definitions to Cursor's MCP tool protobuf format. */
 function buildMcpToolDefinitions(tools) {
@@ -1087,31 +1329,34 @@ 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, sessionId) {
+/** 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}:${modelId}`)
+            .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, sessionId) {
+function deriveConversationKey(messages, sessionId, agentKey) {
     if (sessionId) {
+        const normalizedAgent = normalizeAgentKey(agentKey);
         return createHash("sha256")
-            .update(`session:${sessionId}`)
+            .update(`session:${sessionId}:${normalizedAgent}`)
             .digest("hex")
             .slice(0, 16);
     }
     return createHash("sha256")
-        .update(buildConversationFingerprint(messages))
+        .update(`${normalizeAgentKey(agentKey)}:${buildConversationFingerprint(messages)}`)
         .digest("hex")
         .slice(0, 16);
 }
@@ -1121,8 +1366,114 @@ function buildConversationFingerprint(messages) {
         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({
@@ -1170,6 +1521,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) => {
@@ -1183,8 +1535,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.
@@ -1194,8 +1548,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: [{
@@ -1215,6 +1582,11 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools,
                             blobStore,
                             mcpTools,
                             pendingExecs: state.pendingExecs,
+                            modelId,
+                            metadata: {
+                                ...metadata,
+                                assistantSeedText,
+                            },
                         });
                         sendSSE(makeChunk({}, "tool_calls"));
                         sendDone();
@@ -1263,8 +1635,11 @@ 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();
@@ -1298,13 +1673,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);
@@ -1344,12 +1726,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",
@@ -1358,17 +1743,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,
@@ -1385,7 +1771,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;
@@ -1421,10 +1817,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.c1bf17c092a2",
+  "version": "0.0.0-dev.c1f285cb4d7e",
   "description": "OpenCode plugin that connects Cursor's API to OpenCode via OAuth, model discovery, and a local OpenAI-compatible proxy.",
   "license": "MIT",
   "type": "module",