@playwo/opencode-cursor-oauth 0.0.0-dev.e795e5ffd849 → 0.0.0-dev.e95256212849

package/dist/proxy/bridge-streaming.js

@@ -0,0 +1,342 @@
+import { create, fromBinary, toBinary } from "@bufbuild/protobuf";
+import { AgentClientMessageSchema, AgentServerMessageSchema, ExecClientMessageSchema, McpErrorSchema, McpResultSchema, McpSuccessSchema, McpTextContentSchema, McpToolResultContentItemSchema, } from "../proto/agent_pb";
+import { errorDetails, logPluginError, logPluginWarn } from "../logger";
+import { formatToolCallSummary, formatToolResultSummary, } from "../openai/messages";
+import { activeBridges, updateStoredConversationAfterCompletion, } from "./conversation-state";
+import { startBridge } from "./bridge-session";
+import { updateConversationCheckpoint, syncStoredBlobStore, } from "./state-sync";
+import { SSE_HEADERS } from "./sse";
+import { computeUsage, createConnectFrameParser, createThinkingTagFilter, parseConnectEndStream, processServerMessage, scheduleBridgeEnd, } from "./stream-dispatch";
+const SSE_KEEPALIVE_INTERVAL_MS = 15_000;
+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);
+    let keepaliveTimer;
+    const stopKeepalive = () => {
+        if (!keepaliveTimer)
+            return;
+        clearInterval(keepaliveTimer);
+        keepaliveTimer = undefined;
+    };
+    const stream = new ReadableStream({
+        start(controller) {
+            const encoder = new TextEncoder();
+            let closed = false;
+            const state = {
+                toolCallIndex: 0,
+                pendingExecs: [],
+                outputTokens: 0,
+                totalTokens: 0,
+                interactionToolArgsText: new Map(),
+                emittedToolCallIds: new Set(),
+            };
+            const tagFilter = createThinkingTagFilter();
+            let assistantText = metadata.assistantSeedText ?? "";
+            let mcpExecReceived = false;
+            let endStreamError = null;
+            const sendSSE = (data) => {
+                if (closed)
+                    return;
+                controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}\n\n`));
+            };
+            const sendKeepalive = () => {
+                if (closed)
+                    return;
+                controller.enqueue(encoder.encode(": keep-alive\n\n"));
+            };
+            const sendDone = () => {
+                if (closed)
+                    return;
+                controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+            };
+            const failStream = (message, code) => {
+                if (closed)
+                    return;
+                sendSSE({
+                    error: {
+                        message,
+                        type: "server_error",
+                        ...(code ? { code } : {}),
+                    },
+                });
+                sendDone();
+                closeController();
+            };
+            const closeController = () => {
+                if (closed)
+                    return;
+                closed = true;
+                stopKeepalive();
+                controller.close();
+            };
+            const makeChunk = (delta, finishReason = null) => ({
+                id: completionId,
+                object: "chat.completion.chunk",
+                created,
+                model: modelId,
+                choices: [{ index: 0, delta, finish_reason: finishReason }],
+            });
+            const makeUsageChunk = () => {
+                const { prompt_tokens, completion_tokens, total_tokens } = computeUsage(state);
+                return {
+                    id: completionId,
+                    object: "chat.completion.chunk",
+                    created,
+                    model: modelId,
+                    choices: [],
+                    usage: { prompt_tokens, completion_tokens, total_tokens },
+                };
+            };
+            const processChunk = createConnectFrameParser((messageBytes) => {
+                try {
+                    const serverMessage = fromBinary(AgentServerMessageSchema, messageBytes);
+                    processServerMessage(serverMessage, blobStore, mcpTools, (data) => bridge.write(data), state, (text, isThinking) => {
+                        if (isThinking) {
+                            sendSSE(makeChunk({ reasoning_content: text }));
+                            return;
+                        }
+                        const { content, reasoning } = tagFilter.process(text);
+                        if (reasoning)
+                            sendSSE(makeChunk({ reasoning_content: reasoning }));
+                        if (content) {
+                            assistantText += content;
+                            sendSSE(makeChunk({ content }));
+                        }
+                    }, (exec) => {
+                        const existingIndex = state.pendingExecs.findIndex((candidate) => candidate.toolCallId === exec.toolCallId);
+                        if (existingIndex >= 0) {
+                            state.pendingExecs[existingIndex] = exec;
+                        }
+                        else {
+                            state.pendingExecs.push(exec);
+                        }
+                        mcpExecReceived = true;
+                        const flushed = tagFilter.flush();
+                        if (flushed.reasoning)
+                            sendSSE(makeChunk({ reasoning_content: flushed.reasoning }));
+                        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");
+                        sendSSE(makeChunk({
+                            tool_calls: [
+                                {
+                                    index: state.toolCallIndex++,
+                                    id: exec.toolCallId,
+                                    type: "function",
+                                    function: {
+                                        name: exec.toolName,
+                                        arguments: exec.decodedArgs,
+                                    },
+                                },
+                            ],
+                        }));
+                        activeBridges.set(bridgeKey, {
+                            bridge,
+                            heartbeatTimer,
+                            blobStore,
+                            mcpTools,
+                            pendingExecs: state.pendingExecs,
+                            modelId,
+                            metadata: {
+                                ...metadata,
+                                assistantSeedText,
+                            },
+                        });
+                        sendSSE(makeChunk({}, "tool_calls"));
+                        sendDone();
+                        closeController();
+                    }, (checkpointBytes) => updateConversationCheckpoint(convKey, checkpointBytes), () => scheduleBridgeEnd(bridge), (info) => {
+                        endStreamError = new Error(`Cursor returned unsupported ${info.category}: ${info.caseName}${info.detail ? ` (${info.detail})` : ""}`);
+                        logPluginError("Closing Cursor bridge after unsupported message", {
+                            modelId,
+                            bridgeKey,
+                            convKey,
+                            category: info.category,
+                            caseName: info.caseName,
+                            detail: info.detail,
+                        });
+                        scheduleBridgeEnd(bridge);
+                    }, (info) => {
+                        endStreamError = new Error(`Cursor requested unsupported exec type: ${info.execCase}`);
+                        logPluginError("Closing Cursor bridge after unsupported exec", {
+                            modelId,
+                            bridgeKey,
+                            convKey,
+                            execCase: info.execCase,
+                            execId: info.execId,
+                            execMsgId: info.execMsgId,
+                        });
+                        scheduleBridgeEnd(bridge);
+                    });
+                }
+                catch {
+                    // Skip unparseable messages.
+                }
+            }, (endStreamBytes) => {
+                endStreamError = parseConnectEndStream(endStreamBytes);
+                if (endStreamError) {
+                    logPluginError("Cursor stream returned Connect end-stream error", {
+                        modelId,
+                        bridgeKey,
+                        convKey,
+                        ...errorDetails(endStreamError),
+                    });
+                }
+                scheduleBridgeEnd(bridge);
+            });
+            keepaliveTimer = setInterval(() => {
+                try {
+                    sendKeepalive();
+                }
+                catch (error) {
+                    logPluginWarn("Failed to write SSE keepalive", {
+                        modelId,
+                        bridgeKey,
+                        convKey,
+                        ...errorDetails(error),
+                    });
+                    stopKeepalive();
+                }
+            }, SSE_KEEPALIVE_INTERVAL_MS);
+            bridge.onData(processChunk);
+            bridge.onClose((code) => {
+                clearInterval(heartbeatTimer);
+                stopKeepalive();
+                syncStoredBlobStore(convKey, blobStore);
+                if (endStreamError) {
+                    activeBridges.delete(bridgeKey);
+                    failStream(endStreamError.message, "cursor_bridge_closed");
+                    return;
+                }
+                if (!mcpExecReceived) {
+                    const flushed = tagFilter.flush();
+                    if (flushed.reasoning)
+                        sendSSE(makeChunk({ reasoning_content: flushed.reasoning }));
+                    if (flushed.content) {
+                        assistantText += flushed.content;
+                        sendSSE(makeChunk({ content: flushed.content }));
+                    }
+                    updateStoredConversationAfterCompletion(convKey, metadata, assistantText);
+                    sendSSE(makeChunk({}, "stop"));
+                    sendSSE(makeUsageChunk());
+                    sendDone();
+                    closeController();
+                    return;
+                }
+                activeBridges.delete(bridgeKey);
+                if (code !== 0 && !closed) {
+                    failStream("Cursor bridge connection lost", "cursor_bridge_closed");
+                }
+            });
+        },
+        cancel(reason) {
+            stopKeepalive();
+            clearInterval(heartbeatTimer);
+            syncStoredBlobStore(convKey, blobStore);
+            const active = activeBridges.get(bridgeKey);
+            if (active?.bridge === bridge) {
+                activeBridges.delete(bridgeKey);
+            }
+            logPluginWarn("OpenCode client disconnected from Cursor SSE stream", {
+                modelId,
+                bridgeKey,
+                convKey,
+                reason: reason instanceof Error ? reason.message : String(reason ?? ""),
+            });
+            bridge.end();
+        },
+    });
+    return new Response(stream, { headers: SSE_HEADERS });
+}
+export 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, metadata);
+}
+async function waitForResolvablePendingExecs(active, toolResults, timeoutMs = 2_000) {
+    const pendingToolCallIds = new Set(toolResults.map((result) => result.toolCallId));
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const unresolved = active.pendingExecs.filter((exec) => pendingToolCallIds.has(exec.toolCallId) && exec.execMsgId === 0);
+        if (unresolved.length === 0) {
+            return;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 25));
+    }
+    const unresolved = active.pendingExecs.filter((exec) => pendingToolCallIds.has(exec.toolCallId) && exec.execMsgId === 0);
+    if (unresolved.length > 0) {
+        logPluginWarn("Cursor exec metadata did not arrive before tool-result resume", {
+            bridgeToolCallIds: unresolved.map((exec) => exec.toolCallId),
+            modelId: active.modelId,
+        });
+    }
+}
+export async 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"),
+    };
+    await waitForResolvablePendingExecs(active, toolResults);
+    for (const exec of pendingExecs) {
+        const result = toolResults.find((toolResult) => toolResult.toolCallId === exec.toolCallId);
+        const mcpResult = result
+            ? create(McpResultSchema, {
+                result: {
+                    case: "success",
+                    value: create(McpSuccessSchema, {
+                        content: [
+                            create(McpToolResultContentItemSchema, {
+                                content: {
+                                    case: "text",
+                                    value: create(McpTextContentSchema, {
+                                        text: result.content,
+                                    }),
+                                },
+                            }),
+                        ],
+                        isError: false,
+                    }),
+                },
+            })
+            : create(McpResultSchema, {
+                result: {
+                    case: "error",
+                    value: create(McpErrorSchema, {
+                        error: "Tool result not provided",
+                    }),
+                },
+            });
+        const execClientMessage = create(ExecClientMessageSchema, {
+            id: exec.execMsgId,
+            execId: exec.execId,
+            message: {
+                case: "mcpResult",
+                value: mcpResult,
+            },
+        });
+        const clientMessage = create(AgentClientMessageSchema, {
+            message: { case: "execClientMessage", value: execClientMessage },
+        });
+        bridge.write(toBinary(AgentClientMessageSchema, clientMessage));
+    }
+    return createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools, modelId, bridgeKey, convKey, resumeMetadata);
+}

package/dist/proxy/bridge.d.ts

@@ -0,0 +1,3 @@
+export { startBridge } from "./bridge-session";
+export { handleStreamingResponse, handleToolResultResume, } from "./bridge-streaming";
+export { handleNonStreamingResponse } from "./bridge-non-streaming";

package/dist/proxy/bridge.js

@@ -0,0 +1,3 @@
+export { startBridge } from "./bridge-session";
+export { handleStreamingResponse, handleToolResultResume, } from "./bridge-streaming";
+export { handleNonStreamingResponse } from "./bridge-non-streaming";

package/dist/proxy/chat-completion.d.ts

@@ -0,0 +1,2 @@
+import type { ChatCompletionRequest, ChatRequestContext } from "../openai/types";
+export declare function handleChatCompletion(body: ChatCompletionRequest, accessToken: string, context?: ChatRequestContext): Response | Promise<Response>;

package/dist/proxy/chat-completion.js

@@ -0,0 +1,114 @@
+import { logPluginWarn } from "../logger";
+import { buildInitialHandoffPrompt, buildTitleSourceText, buildToolResumePrompt, detectTitleRequest, parseMessages, } from "../openai/messages";
+import { buildMcpToolDefinitions, selectToolsForChoice } from "../openai/tools";
+import { activeBridges, conversationStates, createStoredConversation, deriveBridgeKey, deriveConversationKey, evictStaleConversations, hashString, normalizeAgentKey, resetStoredConversation, } from "./conversation-state";
+import { buildCursorRequest } from "./cursor-request";
+import { handleNonStreamingResponse, handleStreamingResponse, handleToolResultResume, } from "./bridge";
+import { handleTitleGenerationRequest } from "./title";
+export function handleChatCompletion(body, accessToken, context = {}) {
+    const parsed = parseMessages(body.messages);
+    const { systemPrompt, userText, turns, toolResults, pendingAssistantSummary, completedTurnsFingerprint, } = parsed;
+    const modelId = body.model;
+    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: {
+                message: "No user message found",
+                type: "invalid_request_error",
+            },
+        }), { status: 400, headers: { "Content-Type": "application/json" } });
+    }
+    // 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, 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, bridgeKey, convKey);
+        }
+        // Bridge died (timeout, server disconnect, etc.).
+        // Clean up and fall through to start a fresh bridge.
+        clearInterval(activeBridge.heartbeatTimer);
+        activeBridge.bridge.end();
+    }
+    // Clean up stale bridge if present
+    if (activeBridge && activeBridges.has(bridgeKey)) {
+        clearInterval(activeBridge.heartbeatTimer);
+        activeBridge.bridge.end();
+        activeBridges.delete(bridgeKey);
+    }
+    let stored = conversationStates.get(convKey);
+    if (!stored) {
+        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 hasPendingAssistantSummary = pendingAssistantSummary.trim().length > 0;
+    const needsInitialHandoff = !stored.checkpoint &&
+        (turns.length > 0 || hasPendingAssistantSummary || toolResults.length > 0);
+    const replayTurns = needsInitialHandoff ? [] : turns;
+    let effectiveUserText = needsInitialHandoff
+        ? buildInitialHandoffPrompt(userText, turns, pendingAssistantSummary, toolResults)
+        : toolResults.length > 0 || hasPendingAssistantSummary
+            ? 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, {
+            systemPrompt,
+            systemPromptHash,
+            completedTurnsFingerprint,
+            turns,
+            userText,
+            agentKey: normalizedAgentKey,
+        });
+    }
+    return handleStreamingResponse(payload, accessToken, modelId, bridgeKey, convKey, {
+        systemPrompt,
+        systemPromptHash,
+        completedTurnsFingerprint,
+        turns,
+        userText,
+        agentKey: normalizedAgentKey,
+    });
+}

package/dist/proxy/conversation-meta.d.ts

@@ -0,0 +1,12 @@
+export interface ConversationRequestMetadata {
+    systemPrompt: string;
+    systemPromptHash: string;
+    completedTurnsFingerprint: string;
+    turns: Array<{
+        userText: string;
+        assistantText: string;
+    }>;
+    userText: string;
+    assistantSeedText?: string;
+    agentKey?: string;
+}

package/dist/proxy/conversation-meta.js

@@ -0,0 +1 @@
+export {};

package/dist/proxy/conversation-state.d.ts

@@ -0,0 +1,35 @@
+import type { OpenAIMessage } from "../openai/types";
+import type { ActiveBridge } from "./types";
+export declare const activeBridges: Map<string, ActiveBridge>;
+export interface StoredConversation {
+    conversationId: string;
+    checkpoint: Uint8Array | null;
+    blobStore: Map<string, Uint8Array>;
+    lastAccessMs: number;
+    systemPromptHash: string;
+    completedTurnsFingerprint: string;
+}
+export declare const conversationStates: Map<string, StoredConversation>;
+export declare function evictStaleConversations(): void;
+export declare function normalizeAgentKey(agentKey?: string): string;
+export declare function hashString(value: string): string;
+export declare function createStoredConversation(): StoredConversation;
+export declare function resetStoredConversation(stored: StoredConversation): void;
+export declare function deriveBridgeKey(modelId: string, messages: OpenAIMessage[], sessionId?: string, agentKey?: string): string;
+/** Derive a key for conversation state. Model-independent so context survives model switches. */
+export declare function deriveConversationKey(messages: OpenAIMessage[], sessionId?: string, agentKey?: string): string;
+export declare function buildConversationFingerprint(messages: OpenAIMessage[]): string;
+interface ConversationRequestMetadata {
+    systemPrompt: string;
+    systemPromptHash: string;
+    completedTurnsFingerprint: string;
+    turns: Array<{
+        userText: string;
+        assistantText: string;
+    }>;
+    userText: string;
+    assistantSeedText?: string;
+    agentKey?: string;
+}
+export declare function updateStoredConversationAfterCompletion(convKey: string, metadata: ConversationRequestMetadata, assistantText: string): void;
+export {};

package/dist/proxy/conversation-state.js

@@ -0,0 +1,95 @@
+import { createHash } from "node:crypto";
+import { buildCompletedTurnsFingerprint, textContent, } from "../openai/messages";
+// Active bridges keyed by a session token (derived from conversation state).
+// When tool_calls are returned, the bridge stays alive. The next request
+// with tool results looks up the bridge and sends mcpResult messages.
+export const activeBridges = new Map();
+export const conversationStates = new Map();
+const CONVERSATION_TTL_MS = 30 * 60 * 1000; // 30 minutes
+export function evictStaleConversations() {
+    const now = Date.now();
+    for (const [key, stored] of conversationStates) {
+        if (now - stored.lastAccessMs > CONVERSATION_TTL_MS) {
+            conversationStates.delete(key);
+        }
+    }
+}
+export function normalizeAgentKey(agentKey) {
+    const trimmed = agentKey?.trim();
+    return trimmed ? trimmed : "default";
+}
+export function hashString(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+export function createStoredConversation() {
+    return {
+        conversationId: crypto.randomUUID(),
+        checkpoint: null,
+        blobStore: new Map(),
+        lastAccessMs: Date.now(),
+        systemPromptHash: "",
+        completedTurnsFingerprint: "",
+    };
+}
+export function resetStoredConversation(stored) {
+    stored.conversationId = crypto.randomUUID();
+    stored.checkpoint = null;
+    stored.blobStore = new Map();
+    stored.lastAccessMs = Date.now();
+    stored.systemPromptHash = "";
+    stored.completedTurnsFingerprint = "";
+}
+export 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:${normalizedAgent}:${modelId}:${firstUserText.slice(0, 200)}`)
+        .digest("hex")
+        .slice(0, 16);
+}
+/** Derive a key for conversation state. Model-independent so context survives model switches. */
+export 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(`${normalizeAgentKey(agentKey)}:${buildConversationFingerprint(messages)}`)
+        .digest("hex")
+        .slice(0, 16);
+}
+export 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");
+}
+export 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();
+}

package/dist/proxy/cursor-request.d.ts

@@ -0,0 +1,6 @@
+import type { CursorRequestPayload } from "./types";
+export declare function buildCursorRequest(modelId: string, systemPrompt: string, userText: string, turns: Array<{
+    userText: string;
+    assistantText: string;
+}>, conversationId: string, checkpoint: Uint8Array | null, existingBlobStore?: Map<string, Uint8Array>): CursorRequestPayload;
+export declare function buildCursorResumeRequest(modelId: string, systemPrompt: string, conversationId: string, checkpoint: Uint8Array, existingBlobStore?: Map<string, Uint8Array>): CursorRequestPayload;