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

package/dist/index.js

@@ -128,6 +128,15 @@ export const CursorAuthPlugin = async (input) => {
                 },
             ],
         },
+        async "chat.headers"(incoming, output) {
+            if (incoming.model.providerID !== CURSOR_PROVIDER_ID)
+                return;
+            output.headers["x-opencode-session-id"] = incoming.sessionID;
+            output.headers["x-session-id"] = incoming.sessionID;
+            if (incoming.agent) {
+                output.headers["x-opencode-agent"] = incoming.agent;
+            }
+        },
     };
 };
 function buildCursorProviderModels(models, port) {

package/dist/proxy.js

@@ -41,6 +41,31 @@ function evictStaleConversations() {
         }
     }
 }
+function normalizeAgentKey(agentKey) {
+    const trimmed = agentKey?.trim();
+    return trimmed ? trimmed : "default";
+}
+function hashString(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+function createStoredConversation() {
+    return {
+        conversationId: crypto.randomUUID(),
+        checkpoint: null,
+        blobStore: new Map(),
+        lastAccessMs: Date.now(),
+        systemPromptHash: "",
+        completedTurnsFingerprint: "",
+    };
+}
+function resetStoredConversation(stored) {
+    stored.conversationId = crypto.randomUUID();
+    stored.checkpoint = null;
+    stored.blobStore = new Map();
+    stored.lastAccessMs = Date.now();
+    stored.systemPromptHash = "";
+    stored.completedTurnsFingerprint = "";
+}
 /** Connect protocol frame: [1-byte flags][4-byte BE length][payload] */
 function frameConnectMessage(data, flags = 0) {
     const frame = Buffer.alloc(5 + data.length);
@@ -471,7 +496,11 @@ export async function startProxy(getAccessToken, models = []) {
                         throw new Error("Cursor proxy access token provider not configured");
                     }
                     const accessToken = await proxyAccessTokenProvider();
-                    return handleChatCompletion(body, accessToken);
+                    const sessionId = req.headers.get("x-opencode-session-id")
+                        ?? req.headers.get("x-session-id")
+                        ?? undefined;
+                    const agentKey = req.headers.get("x-opencode-agent") ?? undefined;
+                    return handleChatCompletion(body, accessToken, { sessionId, agentKey });
                 }
                 catch (err) {
                     const message = err instanceof Error ? err.message : String(err);
@@ -509,10 +538,11 @@ 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 tools = selectToolsForChoice(body.tools ?? [], body.tool_choice);
     if (!userText && toolResults.length === 0) {
         return new Response(JSON.stringify({
             error: {
@@ -521,16 +551,24 @@ function handleChatCompletion(body, accessToken) {
             },
         }), { status: 400, headers: { "Content-Type": "application/json" } });
     }
-    // bridgeKey: model-specific, for active tool-call bridges
+    // bridgeKey: session/agent-scoped, for active tool-call bridges
     // convKey: model-independent, for conversation state that survives model switches
-    const bridgeKey = deriveBridgeKey(modelId, body.messages);
-    const convKey = deriveConversationKey(body.messages);
+    const bridgeKey = deriveBridgeKey(modelId, body.messages, context.sessionId, context.agentKey);
+    const convKey = deriveConversationKey(body.messages, context.sessionId, context.agentKey);
     const activeBridge = activeBridges.get(bridgeKey);
     if (activeBridge && toolResults.length > 0) {
         activeBridges.delete(bridgeKey);
         if (activeBridge.bridge.alive) {
+            if (activeBridge.modelId !== modelId) {
+                logPluginWarn("Resuming pending Cursor tool call on original model after model switch", {
+                    requestedModelId: modelId,
+                    resumedModelId: activeBridge.modelId,
+                    convKey,
+                    bridgeKey,
+                });
+            }
             // Resume the live bridge with tool results
-            return handleToolResultResume(activeBridge, toolResults, modelId, bridgeKey, convKey);
+            return handleToolResultResume(activeBridge, toolResults, bridgeKey, convKey);
         }
         // Bridge died (timeout, server disconnect, etc.).
         // Clean up and fall through to start a fresh bridge.
@@ -545,28 +583,43 @@ function handleChatCompletion(body, accessToken) {
     }
     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 effectiveUserText = toolResults.length > 0
+        ? buildToolResumePrompt(userText, pendingAssistantSummary, toolResults)
+        : userText;
     const payload = buildCursorRequest(modelId, systemPrompt, effectiveUserText, turns, 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,
+        });
     }
-    return handleStreamingResponse(payload, accessToken, modelId, bridgeKey, convKey);
+    return handleStreamingResponse(payload, accessToken, modelId, bridgeKey, convKey, {
+        systemPrompt,
+        systemPromptHash,
+        completedTurnsFingerprint,
+        turns,
+        userText,
+    });
 }
 /** Normalize OpenAI message content to a plain string. */
 function textContent(content) {
@@ -581,8 +634,6 @@ function textContent(content) {
 }
 function parseMessages(messages) {
     let systemPrompt = "You are a helpful assistant.";
-    const pairs = [];
-    const toolResults = [];
     // Collect system messages
     const systemParts = messages
         .filter((m) => m.role === "system")
@@ -590,40 +641,152 @@ 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 selectToolsForChoice(tools, toolChoice) {
+    if (!tools.length)
+        return [];
+    if (toolChoice === undefined || toolChoice === null || toolChoice === "auto" || toolChoice === "required") {
+        return tools;
     }
-    let lastUserText = "";
-    if (pendingUser) {
-        lastUserText = pendingUser;
+    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) {
@@ -1084,19 +1247,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) {
+/** 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) {
+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(buildConversationFingerprint(messages))
+        .update(`${normalizeAgentKey(agentKey)}:${buildConversationFingerprint(messages)}`)
         .digest("hex")
         .slice(0, 16);
 }
@@ -1106,8 +1284,19 @@ 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();
+}
 /** Create an SSE streaming Response that reads from a live bridge. */
-function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools, modelId, bridgeKey, convKey) {
+function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools, modelId, bridgeKey, convKey, metadata) {
     const completionId = `chatcmpl-${crypto.randomUUID().replace(/-/g, "").slice(0, 28)}`;
     const created = Math.floor(Date.now() / 1000);
     const stream = new ReadableStream({
@@ -1155,6 +1344,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) => {
@@ -1168,8 +1358,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.
@@ -1179,8 +1371,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: [{
@@ -1200,6 +1405,11 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools,
                             blobStore,
                             mcpTools,
                             pendingExecs: state.pendingExecs,
+                            modelId,
+                            metadata: {
+                                ...metadata,
+                                assistantSeedText,
+                            },
                         });
                         sendSSE(makeChunk({}, "tool_calls"));
                         sendDone();
@@ -1248,8 +1458,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();
@@ -1283,13 +1496,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);
@@ -1329,12 +1549,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",
@@ -1343,17 +1566,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,
@@ -1370,7 +1594,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;
@@ -1406,10 +1640,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.e795e5ffd849",
+  "version": "0.0.0-dev.fc97acd8b777",
   "description": "OpenCode plugin that connects Cursor's API to OpenCode via OAuth, model discovery, and a local OpenAI-compatible proxy.",
   "license": "MIT",
   "type": "module",