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

package/dist/provider/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./model-cost";
+export * from "./models";

package/dist/provider/index.js

@@ -0,0 +1,2 @@
+export * from "./model-cost";
+export * from "./models";

package/dist/provider/model-cost.d.ts

@@ -0,0 +1,9 @@
+export interface ModelCost {
+    input: number;
+    output: number;
+    cache: {
+        read: number;
+        write: number;
+    };
+}
+export declare function estimateModelCost(modelId: string): ModelCost;

package/dist/provider/model-cost.js

@@ -0,0 +1,206 @@
+const MODEL_COST_TABLE = {
+    "claude-4-sonnet": {
+        input: 3,
+        output: 15,
+        cache: { read: 0.3, write: 3.75 },
+    },
+    "claude-4-sonnet-1m": {
+        input: 6,
+        output: 22.5,
+        cache: { read: 0.6, write: 7.5 },
+    },
+    "claude-4.5-haiku": {
+        input: 1,
+        output: 5,
+        cache: { read: 0.1, write: 1.25 },
+    },
+    "claude-4.5-opus": {
+        input: 5,
+        output: 25,
+        cache: { read: 0.5, write: 6.25 },
+    },
+    "claude-4.5-sonnet": {
+        input: 3,
+        output: 15,
+        cache: { read: 0.3, write: 3.75 },
+    },
+    "claude-4.6-opus": {
+        input: 5,
+        output: 25,
+        cache: { read: 0.5, write: 6.25 },
+    },
+    "claude-4.6-opus-fast": {
+        input: 30,
+        output: 150,
+        cache: { read: 3, write: 37.5 },
+    },
+    "claude-4.6-sonnet": {
+        input: 3,
+        output: 15,
+        cache: { read: 0.3, write: 3.75 },
+    },
+    "composer-1": { input: 1.25, output: 10, cache: { read: 0.125, write: 0 } },
+    "composer-1.5": { input: 3.5, output: 17.5, cache: { read: 0.35, write: 0 } },
+    "composer-2": { input: 0.5, output: 2.5, cache: { read: 0.2, write: 0 } },
+    "composer-2-fast": {
+        input: 1.5,
+        output: 7.5,
+        cache: { read: 0.2, write: 0 },
+    },
+    "gemini-2.5-flash": {
+        input: 0.3,
+        output: 2.5,
+        cache: { read: 0.03, write: 0 },
+    },
+    "gemini-3-flash": { input: 0.5, output: 3, cache: { read: 0.05, write: 0 } },
+    "gemini-3-pro": { input: 2, output: 12, cache: { read: 0.2, write: 0 } },
+    "gemini-3-pro-image": {
+        input: 2,
+        output: 12,
+        cache: { read: 0.2, write: 0 },
+    },
+    "gemini-3.1-pro": { input: 2, output: 12, cache: { read: 0.2, write: 0 } },
+    "gpt-5": { input: 1.25, output: 10, cache: { read: 0.125, write: 0 } },
+    "gpt-5-fast": { input: 2.5, output: 20, cache: { read: 0.25, write: 0 } },
+    "gpt-5-mini": { input: 0.25, output: 2, cache: { read: 0.025, write: 0 } },
+    "gpt-5-codex": { input: 1.25, output: 10, cache: { read: 0.125, write: 0 } },
+    "gpt-5.1-codex": {
+        input: 1.25,
+        output: 10,
+        cache: { read: 0.125, write: 0 },
+    },
+    "gpt-5.1-codex-max": {
+        input: 1.25,
+        output: 10,
+        cache: { read: 0.125, write: 0 },
+    },
+    "gpt-5.1-codex-mini": {
+        input: 0.25,
+        output: 2,
+        cache: { read: 0.025, write: 0 },
+    },
+    "gpt-5.2": { input: 1.75, output: 14, cache: { read: 0.175, write: 0 } },
+    "gpt-5.2-codex": {
+        input: 1.75,
+        output: 14,
+        cache: { read: 0.175, write: 0 },
+    },
+    "gpt-5.3-codex": {
+        input: 1.75,
+        output: 14,
+        cache: { read: 0.175, write: 0 },
+    },
+    "gpt-5.4": { input: 2.5, output: 15, cache: { read: 0.25, write: 0 } },
+    "gpt-5.4-mini": {
+        input: 0.75,
+        output: 4.5,
+        cache: { read: 0.075, write: 0 },
+    },
+    "gpt-5.4-nano": { input: 0.2, output: 1.25, cache: { read: 0.02, write: 0 } },
+    "grok-4.20": { input: 2, output: 6, cache: { read: 0.2, write: 0 } },
+    "kimi-k2.5": { input: 0.6, output: 3, cache: { read: 0.1, write: 0 } },
+};
+const MODEL_COST_PATTERNS = [
+    {
+        match: (id) => /claude.*opus.*fast/i.test(id),
+        cost: MODEL_COST_TABLE["claude-4.6-opus-fast"],
+    },
+    {
+        match: (id) => /claude.*opus/i.test(id),
+        cost: MODEL_COST_TABLE["claude-4.6-opus"],
+    },
+    {
+        match: (id) => /claude.*haiku/i.test(id),
+        cost: MODEL_COST_TABLE["claude-4.5-haiku"],
+    },
+    {
+        match: (id) => /claude.*sonnet/i.test(id),
+        cost: MODEL_COST_TABLE["claude-4.6-sonnet"],
+    },
+    {
+        match: (id) => /claude/i.test(id),
+        cost: MODEL_COST_TABLE["claude-4.6-sonnet"],
+    },
+    {
+        match: (id) => /composer-?2/i.test(id),
+        cost: MODEL_COST_TABLE["composer-2"],
+    },
+    {
+        match: (id) => /composer-?1\.5/i.test(id),
+        cost: MODEL_COST_TABLE["composer-1.5"],
+    },
+    {
+        match: (id) => /composer/i.test(id),
+        cost: MODEL_COST_TABLE["composer-1"],
+    },
+    {
+        match: (id) => /gpt-5\.4.*nano/i.test(id),
+        cost: MODEL_COST_TABLE["gpt-5.4-nano"],
+    },
+    {
+        match: (id) => /gpt-5\.4.*mini/i.test(id),
+        cost: MODEL_COST_TABLE["gpt-5.4-mini"],
+    },
+    { match: (id) => /gpt-5\.4/i.test(id), cost: MODEL_COST_TABLE["gpt-5.4"] },
+    {
+        match: (id) => /gpt-5\.3/i.test(id),
+        cost: MODEL_COST_TABLE["gpt-5.3-codex"],
+    },
+    { match: (id) => /gpt-5\.2/i.test(id), cost: MODEL_COST_TABLE["gpt-5.2"] },
+    {
+        match: (id) => /gpt-5\.1.*mini/i.test(id),
+        cost: MODEL_COST_TABLE["gpt-5.1-codex-mini"],
+    },
+    {
+        match: (id) => /gpt-5\.1/i.test(id),
+        cost: MODEL_COST_TABLE["gpt-5.1-codex"],
+    },
+    {
+        match: (id) => /gpt-5.*mini/i.test(id),
+        cost: MODEL_COST_TABLE["gpt-5-mini"],
+    },
+    {
+        match: (id) => /gpt-5.*fast/i.test(id),
+        cost: MODEL_COST_TABLE["gpt-5-fast"],
+    },
+    { match: (id) => /gpt-5/i.test(id), cost: MODEL_COST_TABLE["gpt-5"] },
+    {
+        match: (id) => /gemini.*3\.1/i.test(id),
+        cost: MODEL_COST_TABLE["gemini-3.1-pro"],
+    },
+    {
+        match: (id) => /gemini.*3.*flash/i.test(id),
+        cost: MODEL_COST_TABLE["gemini-3-flash"],
+    },
+    {
+        match: (id) => /gemini.*3/i.test(id),
+        cost: MODEL_COST_TABLE["gemini-3-pro"],
+    },
+    {
+        match: (id) => /gemini.*flash/i.test(id),
+        cost: MODEL_COST_TABLE["gemini-2.5-flash"],
+    },
+    {
+        match: (id) => /gemini/i.test(id),
+        cost: MODEL_COST_TABLE["gemini-3.1-pro"],
+    },
+    { match: (id) => /grok/i.test(id), cost: MODEL_COST_TABLE["grok-4.20"] },
+    { match: (id) => /kimi/i.test(id), cost: MODEL_COST_TABLE["kimi-k2.5"] },
+];
+const DEFAULT_COST = {
+    input: 3,
+    output: 15,
+    cache: { read: 0.3, write: 0 },
+};
+export function estimateModelCost(modelId) {
+    const normalized = modelId.toLowerCase();
+    const exact = MODEL_COST_TABLE[normalized];
+    if (exact)
+        return exact;
+    const stripped = normalized.replace(/-(high|medium|low|preview|thinking|spark-preview)$/g, "");
+    const strippedMatch = MODEL_COST_TABLE[stripped];
+    if (strippedMatch)
+        return strippedMatch;
+    return (MODEL_COST_PATTERNS.find((pattern) => pattern.match(normalized))?.cost ??
+        DEFAULT_COST);
+}

package/dist/provider/models.d.ts

@@ -0,0 +1,8 @@
+import type { CursorModel } from "../models";
+export interface ProviderWithModels {
+    models?: Record<string, unknown>;
+}
+export declare function setProviderModels(provider: unknown, models: Record<string, unknown>): void;
+export declare function buildCursorProviderModels(models: CursorModel[], port: number): Record<string, unknown>;
+export declare function buildDisabledProviderConfig(message: string): Record<string, unknown>;
+export declare function stripAuthorizationHeader(init?: RequestInit): RequestInit | undefined;

package/dist/provider/models.js

@@ -0,0 +1,86 @@
+import { CURSOR_PROVIDER_ID } from "../constants";
+import { estimateModelCost } from "./model-cost";
+export function setProviderModels(provider, models) {
+    if (!provider || typeof provider !== "object")
+        return;
+    provider.models = models;
+}
+export function buildCursorProviderModels(models, port) {
+    return Object.fromEntries(models.map((model) => [
+        model.id,
+        {
+            id: model.id,
+            providerID: CURSOR_PROVIDER_ID,
+            api: {
+                id: model.id,
+                url: `http://localhost:${port}/v1`,
+                npm: "@ai-sdk/openai-compatible",
+            },
+            name: model.name,
+            capabilities: {
+                temperature: true,
+                reasoning: model.reasoning,
+                attachment: false,
+                toolcall: true,
+                input: {
+                    text: true,
+                    audio: false,
+                    image: false,
+                    video: false,
+                    pdf: false,
+                },
+                output: {
+                    text: true,
+                    audio: false,
+                    image: false,
+                    video: false,
+                    pdf: false,
+                },
+                interleaved: false,
+            },
+            cost: estimateModelCost(model.id),
+            limit: {
+                context: model.contextWindow,
+                output: model.maxTokens,
+            },
+            status: "active",
+            options: {},
+            headers: {},
+            release_date: "",
+            variants: {},
+        },
+    ]));
+}
+export function buildDisabledProviderConfig(message) {
+    return {
+        baseURL: "http://127.0.0.1/cursor-disabled/v1",
+        apiKey: "cursor-disabled",
+        async fetch() {
+            return new Response(JSON.stringify({
+                error: {
+                    message,
+                    type: "server_error",
+                    code: "cursor_model_discovery_failed",
+                },
+            }), {
+                status: 503,
+                headers: { "Content-Type": "application/json" },
+            });
+        },
+    };
+}
+export function stripAuthorizationHeader(init) {
+    if (!init?.headers)
+        return init;
+    if (init.headers instanceof Headers) {
+        init.headers.delete("authorization");
+        return init;
+    }
+    if (Array.isArray(init.headers)) {
+        init.headers = init.headers.filter(([key]) => key.toLowerCase() !== "authorization");
+        return init;
+    }
+    delete init.headers["authorization"];
+    delete init.headers["Authorization"];
+    return init;
+}

package/dist/proxy/bridge-close-controller.d.ts

@@ -0,0 +1,6 @@
+import type { CursorSession } from "../cursor/bidi-session";
+export declare function createBridgeCloseController(bridge: CursorSession): {
+    noteTurnEnded: () => void;
+    noteCheckpoint: () => void;
+    dispose: () => void;
+};

package/dist/proxy/bridge-close-controller.js

@@ -0,0 +1,37 @@
+import { scheduleBridgeEnd } from "./stream-dispatch";
+const TURN_END_GRACE_MS = 750;
+export function createBridgeCloseController(bridge) {
+    let turnEnded = false;
+    let checkpointSeen = false;
+    let closeTimer;
+    const clearCloseTimer = () => {
+        if (!closeTimer)
+            return;
+        clearTimeout(closeTimer);
+        closeTimer = undefined;
+    };
+    const closeBridge = () => {
+        clearCloseTimer();
+        scheduleBridgeEnd(bridge);
+    };
+    return {
+        noteTurnEnded() {
+            turnEnded = true;
+            if (checkpointSeen) {
+                closeBridge();
+                return;
+            }
+            clearCloseTimer();
+            closeTimer = setTimeout(closeBridge, TURN_END_GRACE_MS);
+        },
+        noteCheckpoint() {
+            checkpointSeen = true;
+            if (turnEnded) {
+                closeBridge();
+            }
+        },
+        dispose() {
+            clearCloseTimer();
+        },
+    };
+}

package/dist/proxy/bridge-non-streaming.d.ts

@@ -0,0 +1,3 @@
+import type { ConversationRequestMetadata } from "./conversation-meta";
+import type { CursorRequestPayload } from "./types";
+export declare function handleNonStreamingResponse(payload: CursorRequestPayload, accessToken: string, modelId: string, convKey: string, metadata: ConversationRequestMetadata): Promise<Response>;

package/dist/proxy/bridge-non-streaming.js

@@ -0,0 +1,123 @@
+import { fromBinary } from "@bufbuild/protobuf";
+import { AgentServerMessageSchema } from "../proto/agent_pb";
+import { errorDetails, logPluginError } from "../logger";
+import { updateStoredConversationAfterCompletion } from "./conversation-state";
+import { startBridge } from "./bridge-session";
+import { updateConversationCheckpoint, syncStoredBlobStore, } from "./state-sync";
+import { computeUsage, createConnectFrameParser, createThinkingTagFilter, parseConnectEndStream, processServerMessage, scheduleBridgeEnd, } from "./stream-dispatch";
+import { createBridgeCloseController } from "./bridge-close-controller";
+export 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, 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",
+        created,
+        model: modelId,
+        choices: [
+            {
+                index: 0,
+                message,
+                finish_reason: finishReason,
+            },
+        ],
+        usage,
+    }), { headers: { "Content-Type": "application/json" } });
+}
+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 bridgeCloseController = createBridgeCloseController(bridge);
+    const state = {
+        toolCallIndex: 0,
+        pendingExecs: [],
+        outputTokens: 0,
+        totalTokens: 0,
+    };
+    const tagFilter = createThinkingTagFilter();
+    bridge.onData(createConnectFrameParser((messageBytes) => {
+        try {
+            const serverMessage = fromBinary(AgentServerMessageSchema, messageBytes);
+            processServerMessage(serverMessage, payload.blobStore, payload.cloudRule, payload.mcpTools, (data) => bridge.write(data), state, (text, isThinking) => {
+                if (isThinking)
+                    return;
+                const { content } = tagFilter.process(text);
+                fullText += content;
+            }, (exec) => {
+                pendingToolCalls.push({
+                    id: exec.toolCallId,
+                    type: "function",
+                    function: {
+                        name: exec.toolName,
+                        arguments: exec.decodedArgs,
+                    },
+                });
+                scheduleBridgeEnd(bridge);
+            }, (checkpointBytes) => {
+                updateConversationCheckpoint(convKey, checkpointBytes);
+                bridgeCloseController.noteCheckpoint();
+            }, () => bridgeCloseController.noteTurnEnded(), (info) => {
+                endStreamError = new Error(`Cursor returned unsupported ${info.category}: ${info.caseName}${info.detail ? ` (${info.detail})` : ""}`);
+                logPluginError("Closing non-streaming Cursor bridge after unsupported message", {
+                    modelId,
+                    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 non-streaming Cursor bridge after unsupported exec", {
+                    modelId,
+                    convKey,
+                    execCase: info.execCase,
+                    execId: info.execId,
+                    execMsgId: info.execMsgId,
+                });
+                scheduleBridgeEnd(bridge);
+            });
+        }
+        catch {
+            // Skip unparseable messages.
+        }
+    }, (endStreamBytes) => {
+        endStreamError = parseConnectEndStream(endStreamBytes);
+        if (endStreamError) {
+            logPluginError("Cursor non-streaming response returned Connect end-stream error", {
+                modelId,
+                convKey,
+                ...errorDetails(endStreamError),
+            });
+        }
+        scheduleBridgeEnd(bridge);
+    }));
+    bridge.onClose(() => {
+        bridgeCloseController.dispose();
+        clearInterval(heartbeatTimer);
+        syncStoredBlobStore(convKey, payload.blobStore);
+        const flushed = tagFilter.flush();
+        fullText += flushed.content;
+        if (endStreamError) {
+            reject(endStreamError);
+            return;
+        }
+        if (pendingToolCalls.length === 0) {
+            updateStoredConversationAfterCompletion(convKey, metadata, fullText);
+        }
+        resolve({
+            text: fullText,
+            usage: computeUsage(state),
+            finishReason: pendingToolCalls.length > 0 ? "tool_calls" : "stop",
+            toolCalls: pendingToolCalls,
+        });
+    });
+    return promise;
+}

package/dist/proxy/bridge-session.d.ts

@@ -0,0 +1,5 @@
+import type { CursorSession } from "../cursor/bidi-session";
+export declare function startBridge(accessToken: string, requestBytes: Uint8Array): Promise<{
+    bridge: CursorSession;
+    heartbeatTimer: NodeJS.Timeout;
+}>;

package/dist/proxy/bridge-session.js

@@ -0,0 +1,11 @@
+import { createCursorSession } from "../cursor/bidi-session";
+import { makeHeartbeatBytes } from "./stream-dispatch";
+const HEARTBEAT_INTERVAL_MS = 5_000;
+export async function startBridge(accessToken, requestBytes) {
+    const bridge = await createCursorSession({
+        accessToken,
+        initialRequestBytes: requestBytes,
+    });
+    const heartbeatTimer = setInterval(() => bridge.write(makeHeartbeatBytes()), HEARTBEAT_INTERVAL_MS);
+    return { bridge, heartbeatTimer };
+}

package/dist/proxy/bridge-streaming.d.ts

@@ -0,0 +1,5 @@
+import { type ToolResultInfo } from "../openai/messages";
+import type { ConversationRequestMetadata } from "./conversation-meta";
+import type { ActiveBridge, CursorRequestPayload } from "./types";
+export declare function handleStreamingResponse(payload: CursorRequestPayload, accessToken: string, modelId: string, bridgeKey: string, convKey: string, metadata: ConversationRequestMetadata): Promise<Response>;
+export declare function handleToolResultResume(active: ActiveBridge, toolResults: ToolResultInfo[], bridgeKey: string, convKey: string): Promise<Response>;