@playwo/opencode-cursor-oauth 0.0.0-dev.c80ebcb27754 → 0.0.0-dev.d7836f7ad39f

package/dist/models.js

@@ -1,13 +1,10 @@
-/**
- * Cursor model discovery via GetUsableModels.
- * Uses the H2 bridge for transport. Falls back to a hardcoded list
- * when discovery fails.
- */
 import { create, fromBinary, toBinary } from "@bufbuild/protobuf";
 import { z } from "zod";
-import { callCursorUnaryRpc } from "./proxy";
+import { callCursorUnaryRpc, decodeConnectUnaryBody } from "./cursor";
+import { errorDetails, logPluginError, logPluginWarn } from "./logger";
 import { GetUsableModelsRequestSchema, GetUsableModelsResponseSchema, } from "./proto/agent_pb";
 const GET_USABLE_MODELS_PATH = "/agent.v1.AgentService/GetUsableModels";
+const MODEL_DISCOVERY_TIMEOUT_MS = 5_000;
 const DEFAULT_CONTEXT_WINDOW = 200_000;
 const DEFAULT_MAX_TOKENS = 64_000;
 const CursorModelDetailsSchema = z.object({
@@ -22,24 +19,12 @@ const CursorModelDetailsSchema = z.object({
         .transform((aliases) => (aliases ?? []).filter((alias) => typeof alias === "string")),
     thinkingDetails: z.unknown().optional(),
 });
-const FALLBACK_MODELS = [
-    // Composer models
-    { id: "composer-1", name: "Composer 1", reasoning: true, contextWindow: 200_000, maxTokens: 64_000 },
-    { id: "composer-1.5", name: "Composer 1.5", reasoning: true, contextWindow: 200_000, maxTokens: 64_000 },
-    // Claude models
-    { id: "claude-4.6-opus-high", name: "Claude 4.6 Opus", reasoning: true, contextWindow: 200_000, maxTokens: 128_000 },
-    { id: "claude-4.6-sonnet-medium", name: "Claude 4.6 Sonnet", reasoning: true, contextWindow: 200_000, maxTokens: 64_000 },
-    { id: "claude-4.5-sonnet", name: "Claude 4.5 Sonnet", reasoning: true, contextWindow: 200_000, maxTokens: 64_000 },
-    // GPT models
-    { id: "gpt-5.4-medium", name: "GPT-5.4", reasoning: true, contextWindow: 272_000, maxTokens: 128_000 },
-    { id: "gpt-5.2", name: "GPT-5.2", reasoning: true, contextWindow: 400_000, maxTokens: 128_000 },
-    { id: "gpt-5.2-codex", name: "GPT-5.2 Codex", reasoning: true, contextWindow: 400_000, maxTokens: 128_000 },
-    { id: "gpt-5.3-codex", name: "GPT-5.3 Codex", reasoning: true, contextWindow: 400_000, maxTokens: 128_000 },
-    { id: "gpt-5.3-codex-spark-preview", name: "GPT-5.3 Codex Spark", reasoning: true, contextWindow: 128_000, maxTokens: 128_000 },
-    // Other models
-    { id: "gemini-3.1-pro", name: "Gemini 3.1 Pro", reasoning: true, contextWindow: 1_000_000, maxTokens: 64_000 },
-    { id: "grok-code-fast-1", name: "Grok Code Fast 1", reasoning: false, contextWindow: 128_000, maxTokens: 64_000 },
-];
+export class CursorModelDiscoveryError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "CursorModelDiscoveryError";
+    }
+}
 async function fetchCursorUsableModels(apiKey) {
     try {
         const requestPayload = create(GetUsableModelsRequestSchema, {});
@@ -48,18 +33,51 @@ async function fetchCursorUsableModels(apiKey) {
             accessToken: apiKey,
             rpcPath: GET_USABLE_MODELS_PATH,
             requestBody,
+            timeoutMs: MODEL_DISCOVERY_TIMEOUT_MS,
         });
-        if (response.timedOut || response.exitCode !== 0 || response.body.length === 0) {
-            return null;
+        if (response.timedOut) {
+            logPluginError("Cursor model discovery timed out", {
+                rpcPath: GET_USABLE_MODELS_PATH,
+                timeoutMs: MODEL_DISCOVERY_TIMEOUT_MS,
+            });
+            throw new CursorModelDiscoveryError(`Cursor model discovery timed out after ${MODEL_DISCOVERY_TIMEOUT_MS}ms.`);
+        }
+        if (response.exitCode !== 0) {
+            logPluginError("Cursor model discovery HTTP failure", {
+                rpcPath: GET_USABLE_MODELS_PATH,
+                exitCode: response.exitCode,
+                responseBody: response.body,
+            });
+            throw new CursorModelDiscoveryError(buildDiscoveryHttpError(response.exitCode, response.body));
+        }
+        if (response.body.length === 0) {
+            logPluginWarn("Cursor model discovery returned an empty response", {
+                rpcPath: GET_USABLE_MODELS_PATH,
+            });
+            throw new CursorModelDiscoveryError("Cursor model discovery returned an empty response.");
         }
         const decoded = decodeGetUsableModelsResponse(response.body);
-        if (!decoded)
-            return null;
+        if (!decoded) {
+            logPluginError("Cursor model discovery returned an unreadable response", {
+                rpcPath: GET_USABLE_MODELS_PATH,
+                responseBody: response.body,
+            });
+            throw new CursorModelDiscoveryError("Cursor model discovery returned an unreadable response.");
+        }
         const models = normalizeCursorModels(decoded.models);
-        return models.length > 0 ? models : null;
+        if (models.length === 0) {
+            throw new CursorModelDiscoveryError("Cursor model discovery returned no usable models.");
+        }
+        return models;
     }
-    catch {
-        return null;
+    catch (error) {
+        if (error instanceof CursorModelDiscoveryError)
+            throw error;
+        logPluginError("Cursor model discovery crashed", {
+            rpcPath: GET_USABLE_MODELS_PATH,
+            ...errorDetails(error),
+        });
+        throw new CursorModelDiscoveryError("Cursor model discovery failed.");
     }
 }
 let cachedModels = null;
@@ -67,13 +85,43 @@ export async function getCursorModels(apiKey) {
     if (cachedModels)
         return cachedModels;
     const discovered = await fetchCursorUsableModels(apiKey);
-    cachedModels = discovered && discovered.length > 0 ? discovered : FALLBACK_MODELS;
+    cachedModels = discovered;
     return cachedModels;
 }
 /** @internal Test-only. */
 export function clearModelCache() {
     cachedModels = null;
 }
+function buildDiscoveryHttpError(exitCode, body) {
+    const detail = extractDiscoveryErrorDetail(body);
+    const protocolHint = exitCode === 464
+        ? " Likely protocol mismatch: Cursor appears to expect an HTTP/2 Connect unary request."
+        : "";
+    if (!detail) {
+        return `Cursor model discovery failed with HTTP ${exitCode}.${protocolHint}`;
+    }
+    return `Cursor model discovery failed with HTTP ${exitCode}: ${detail}.${protocolHint}`;
+}
+function extractDiscoveryErrorDetail(body) {
+    if (body.length === 0)
+        return null;
+    const text = new TextDecoder().decode(body).trim();
+    if (!text)
+        return null;
+    try {
+        const parsed = JSON.parse(text);
+        const code = typeof parsed.code === "string" ? parsed.code : undefined;
+        const message = typeof parsed.message === "string" ? parsed.message : undefined;
+        if (message && code)
+            return `${message} (${code})`;
+        if (message)
+            return message;
+        if (code)
+            return code;
+    }
+    catch { }
+    return text.length > 200 ? `${text.slice(0, 197)}...` : text;
+}
 function decodeGetUsableModelsResponse(payload) {
     try {
         return fromBinary(GetUsableModelsResponseSchema, payload);
@@ -90,28 +138,6 @@ function decodeGetUsableModelsResponse(payload) {
         }
     }
 }
-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;
-        // Compression flag
-        if ((flags & 0b0000_0001) !== 0)
-            return null;
-        // End-of-stream flag — skip trailer frames
-        if ((flags & 0b0000_0010) === 0) {
-            return payload.subarray(offset + 5, frameEnd);
-        }
-        offset = frameEnd;
-    }
-    return null;
-}
 function normalizeCursorModels(models) {
     if (models.length === 0)
         return [];

package/dist/openai/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./messages";
+export * from "./tools";
+export * from "./types";

package/dist/openai/index.js

@@ -0,0 +1,3 @@
+export * from "./messages";
+export * from "./tools";
+export * from "./types";

package/dist/openai/messages.d.ts

@@ -0,0 +1,40 @@
+import type { ChatCompletionRequest, OpenAIMessage, OpenAIToolCall } from "./types";
+export interface ToolResultInfo {
+    toolCallId: string;
+    content: string;
+}
+interface ParsedMessages {
+    systemPrompt: string;
+    userText: string;
+    turns: Array<{
+        userText: string;
+        assistantText: string;
+    }>;
+    toolResults: ToolResultInfo[];
+    pendingAssistantSummary: string;
+    completedTurnsFingerprint: string;
+    assistantContinuation: boolean;
+}
+/** Normalize OpenAI message content to a plain string. */
+export declare function textContent(content: OpenAIMessage["content"]): string;
+export declare function parseMessages(messages: OpenAIMessage[]): ParsedMessages;
+export declare function formatToolCallSummary(call: OpenAIToolCall): string;
+export declare function formatToolResultSummary(result: ToolResultInfo): string;
+export declare function buildCompletedTurnsFingerprint(systemPrompt: string, turns: Array<{
+    userText: string;
+    assistantText: string;
+}>): string;
+export declare function buildToolResumePrompt(userText: string, pendingAssistantSummary: string, toolResults: ToolResultInfo[]): string;
+export declare function buildInitialHandoffPrompt(userText: string, turns: Array<{
+    userText: string;
+    assistantText: string;
+}>, pendingAssistantSummary: string, toolResults: ToolResultInfo[]): string;
+export declare function buildTitleSourceText(userText: string, turns: Array<{
+    userText: string;
+    assistantText: string;
+}>, pendingAssistantSummary: string, toolResults: ToolResultInfo[]): string;
+export declare function detectTitleRequest(body: ChatCompletionRequest): {
+    matched: boolean;
+    reason: string;
+};
+export {};

package/dist/openai/messages.js

@@ -0,0 +1,231 @@
+import { createHash } from "node:crypto";
+import { OPENCODE_TITLE_REQUEST_MARKER } from "../constants";
+/** Normalize OpenAI message content to a plain string. */
+export function textContent(content) {
+    if (content == null)
+        return "";
+    if (typeof content === "string")
+        return content;
+    return content
+        .filter((p) => p.type === "text" && p.text)
+        .map((p) => p.text)
+        .join("\n");
+}
+export function parseMessages(messages) {
+    let systemPrompt = "You are a helpful assistant.";
+    // Collect system messages
+    const systemParts = messages
+        .filter((m) => m.role === "system")
+        .map((m) => textContent(m.content));
+    if (systemParts.length > 0) {
+        systemPrompt = systemParts.join("\n");
+    }
+    const nonSystem = messages.filter((m) => m.role !== "system");
+    const parsedTurns = [];
+    let currentTurn;
+    for (const msg of nonSystem) {
+        if (msg.role === "user") {
+            if (currentTurn)
+                parsedTurns.push(currentTurn);
+            currentTurn = {
+                userText: textContent(msg.content),
+                segments: [],
+            };
+            continue;
+        }
+        if (!currentTurn) {
+            currentTurn = { userText: "", segments: [] };
+        }
+        if (msg.role === "assistant") {
+            const text = textContent(msg.content);
+            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 assistantContinuation = false;
+    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;
+        }
+        else if (lastTurn.userText && hasAssistantSummary) {
+            completedTurnStates = parsedTurns.slice(0, -1);
+            userText = lastTurn.userText;
+            pendingAssistantSummary = summarizeTurnSegments(lastTurn.segments);
+            assistantContinuation = true;
+        }
+    }
+    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),
+        assistantContinuation,
+    };
+}
+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();
+}
+export 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}]`;
+}
+export 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;
+}
+export function buildCompletedTurnsFingerprint(systemPrompt, turns) {
+    return createHash("sha256")
+        .update(JSON.stringify({ systemPrompt, turns }))
+        .digest("hex");
+}
+export 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");
+}
+export 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");
+}
+export function buildTitleSourceText(userText, turns, pendingAssistantSummary, toolResults) {
+    const history = turns
+        .map((turn) => [
+        isTitleRequestMarker(turn.userText) ? "" : turn.userText.trim(),
+        turn.assistantText.trim(),
+    ]
+        .filter(Boolean)
+        .join("\n"))
+        .filter(Boolean);
+    if (pendingAssistantSummary.trim()) {
+        history.push(pendingAssistantSummary.trim());
+    }
+    if (toolResults.length > 0) {
+        history.push(toolResults.map(formatToolResultSummary).join("\n\n"));
+    }
+    if (userText.trim() && !isTitleRequestMarker(userText)) {
+        history.push(userText.trim());
+    }
+    return history.join("\n\n").trim();
+}
+export function detectTitleRequest(body) {
+    if ((body.tools?.length ?? 0) > 0) {
+        return { matched: false, reason: "tools-present" };
+    }
+    const firstNonSystem = body.messages.find((message) => message.role !== "system");
+    if (firstNonSystem?.role === "user" &&
+        isTitleRequestMarker(textContent(firstNonSystem.content))) {
+        return { matched: true, reason: "opencode-title-marker" };
+    }
+    return { matched: false, reason: "no-title-marker" };
+}
+function isTitleRequestMarker(text) {
+    return text.trim() === OPENCODE_TITLE_REQUEST_MARKER;
+}

package/dist/openai/tools.d.ts

@@ -0,0 +1,7 @@
+import type { McpToolDefinition } from "../proto/agent_pb";
+import type { OpenAIToolDef } from "./types";
+export declare function selectToolsForChoice(tools: OpenAIToolDef[], toolChoice: unknown): OpenAIToolDef[];
+/** Convert OpenAI tool definitions to Cursor's MCP tool protobuf format. */
+export declare function buildMcpToolDefinitions(tools: OpenAIToolDef[]): McpToolDefinition[];
+/** Decode a map of MCP arg values. */
+export declare function decodeMcpArgsMap(args: Record<string, Uint8Array>): Record<string, unknown>;

package/dist/openai/tools.js

@@ -0,0 +1,58 @@
+import { create, fromBinary, fromJson, toBinary, toJson, } from "@bufbuild/protobuf";
+import { ValueSchema } from "@bufbuild/protobuf/wkt";
+import { McpToolDefinitionSchema } from "../proto/agent_pb";
+export function selectToolsForChoice(tools, toolChoice) {
+    if (!tools.length)
+        return [];
+    if (toolChoice === undefined ||
+        toolChoice === null ||
+        toolChoice === "auto" ||
+        toolChoice === "required") {
+        return tools;
+    }
+    if (toolChoice === "none") {
+        return [];
+    }
+    if (typeof toolChoice === "object") {
+        const choice = toolChoice;
+        if (choice.type === "function" &&
+            typeof choice.function?.name === "string") {
+            return tools.filter((tool) => tool.function.name === choice.function.name);
+        }
+    }
+    return tools;
+}
+/** Convert OpenAI tool definitions to Cursor's MCP tool protobuf format. */
+export function buildMcpToolDefinitions(tools) {
+    return tools.map((t) => {
+        const fn = t.function;
+        const jsonSchema = fn.parameters && typeof fn.parameters === "object"
+            ? fn.parameters
+            : { type: "object", properties: {}, required: [] };
+        const inputSchema = toBinary(ValueSchema, fromJson(ValueSchema, jsonSchema));
+        return create(McpToolDefinitionSchema, {
+            name: fn.name,
+            description: fn.description || "",
+            providerIdentifier: "opencode",
+            toolName: fn.name,
+            inputSchema,
+        });
+    });
+}
+/** Decode a Cursor MCP arg value (protobuf Value bytes) to a JS value. */
+function decodeMcpArgValue(value) {
+    try {
+        const parsed = fromBinary(ValueSchema, value);
+        return toJson(ValueSchema, parsed);
+    }
+    catch { }
+    return new TextDecoder().decode(value);
+}
+/** Decode a map of MCP arg values. */
+export function decodeMcpArgsMap(args) {
+    const decoded = {};
+    for (const [key, value] of Object.entries(args)) {
+        decoded[key] = decodeMcpArgValue(value);
+    }
+    return decoded;
+}

package/dist/openai/types.d.ts

@@ -0,0 +1,41 @@
+export interface OpenAIToolCall {
+    id: string;
+    type: "function";
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+/** A single element in an OpenAI multi-part content array. */
+export interface ContentPart {
+    type: string;
+    text?: string;
+}
+export interface OpenAIMessage {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string | null | ContentPart[];
+    tool_call_id?: string;
+    tool_calls?: OpenAIToolCall[];
+}
+export interface OpenAIToolDef {
+    type: "function";
+    function: {
+        name: string;
+        description?: string;
+        parameters?: Record<string, unknown>;
+    };
+}
+export interface ChatCompletionRequest {
+    model: string;
+    messages: OpenAIMessage[];
+    stream?: boolean;
+    temperature?: number;
+    max_tokens?: number;
+    max_completion_tokens?: number;
+    tools?: OpenAIToolDef[];
+    tool_choice?: unknown;
+}
+export interface ChatRequestContext {
+    sessionId?: string;
+    agentKey?: string;
+}

package/dist/openai/types.js

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

package/dist/plugin/cursor-auth-plugin.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "@opencode-ai/plugin";
+export declare const CursorAuthPlugin: Plugin;
+export default CursorAuthPlugin;