@ngotrnghia1811/opencode-windsurf-auth 0.1.0

package/dist/windsurf-provider.js

@@ -0,0 +1,535 @@
+import { launchProxyStream } from "./thinking-proxy";
+import { loadWindsurfJwt } from "./credentials";
+import { encodeGetChatMessageRequest } from "./chat-request";
+import { streamGetChatMessage } from "./chat-client";
+function getDevinPath() {
+    const p = Bun.which("devin");
+    if (!p)
+        throw new Error("devin CLI not found — run `devin /login` first");
+    return p;
+}
+const ZERO_USAGE = {
+    inputTokens: { total: undefined, noCache: undefined, cacheRead: undefined, cacheWrite: undefined },
+    outputTokens: { total: undefined, text: undefined, reasoning: undefined },
+};
+const STOP_REASON = { unified: "stop", raw: "stop" };
+const TOOL_CALLS_REASON = { unified: "tool-calls", raw: "tool_use" };
+const ERROR_REASON = { unified: "error", raw: "error" };
+const STREAM_TIMEOUT_MS = 300_000;
+const EMPTY_RESULT_ERROR = new Error("Windsurf produced no content (empty stream — possible backend drop or timeout)");
+function trackContent(tracker, type) {
+    if (type === "text-delta" ||
+        type === "text-start" ||
+        type === "reasoning-delta" ||
+        type === "reasoning-start" ||
+        type === "tool-call" ||
+        type === "tool-input-start") {
+        tracker.emitted = true;
+    }
+}
+function stripDevinBanner(text) {
+    const noAnsi = text.replace(/\x1b\[[0-9;]*m/g, "");
+    const bannerPatterns = [
+        "Welcome to Devin CLI",
+        "Logged in as",
+        "You're all set",
+        "✓ Organization",
+    ];
+    const lines = noAnsi.split("\n");
+    let start = 0;
+    for (let i = 0; i < lines.length; i++) {
+        if (bannerPatterns.some((p) => lines[i].includes(p))) {
+            start = i + 1;
+            continue;
+        }
+        break;
+    }
+    return lines.slice(start).join("\n");
+}
+function flattenHistory(options) {
+    const tools = options.tools;
+    const toolsPrompt = tools
+        ? `<tools>\n${Object.entries(tools)
+            .map(([name, def]) => `  ${name}: ${def.description ?? name}`)
+            .join("\n")}\n</tools>\n\n`
+        : "";
+    const messages = options.prompt
+        .map((msg) => {
+        const role = msg.role;
+        const parts = typeof msg.content === "string" ? msg.content : msg.content;
+        if (typeof parts === "string")
+            return `${role}: ${parts}`;
+        return `${role}: ${parts
+            .map((p) => {
+            if (p.type === "text")
+                return p.text;
+            if (p.type === "tool-result") {
+                const tr = p;
+                return `[tool result #${tr.toolCallId}: ${JSON.stringify(tr.output)}]`;
+            }
+            return "";
+        })
+            .join("")}`;
+    })
+        .join("\n\n");
+    return toolsPrompt + messages;
+}
+// ── Level-2: direct Connect-RPC to Windsurf API ─────────────────────────────
+function extractSystemPrompt(options) {
+    for (const msg of options.prompt) {
+        if (msg.role === "system")
+            return msg.content;
+    }
+    return "";
+}
+/** Extract a plain string from a LanguageModelV3ToolResultOutput. */
+function extractToolOutput(output) {
+    const o = output;
+    if (o.type === "text" && typeof o.value === "string")
+        return o.value;
+    if (o.type === "json")
+        return JSON.stringify(o.value);
+    if (o.type === "error-text" && typeof o.value === "string")
+        return o.value;
+    if (o.type === "error-json")
+        return JSON.stringify(o.value);
+    if (o.type === "execution-denied")
+        return `Execution denied${o.reason ? `: ${o.reason}` : ""}`;
+    if (o.type === "content")
+        return JSON.stringify(o.value);
+    return JSON.stringify(output);
+}
+function convertToProtoMessages(options) {
+    const result = [];
+    for (const msg of options.prompt) {
+        if (msg.role === "system")
+            continue; // handled separately as system_prompt f2
+        if (msg.role === "user") {
+            const content = typeof msg.content === "string"
+                ? msg.content
+                : msg.content
+                    .filter((p) => p.type === "text")
+                    .map((p) => p.text)
+                    .join("");
+            result.push({ role: 1, content });
+            continue;
+        }
+        if (msg.role === "assistant") {
+            const parts = msg.content;
+            // Collect text/reasoning parts into a single text message
+            const text = parts
+                .filter((p) => p.type === "text" || p.type === "reasoning")
+                .map((p) => p.text)
+                .join("");
+            // Emit tool-call parts as separate role=2 messages with f6
+            const toolCalls = parts.filter((p) => p.type === "tool-call");
+            // If there's text, emit as standalone role=2 text message.
+            // Prefer separate from tool-call messages when both are present.
+            if (text) {
+                result.push({ role: 2, content: text });
+            }
+            // Emit each tool-call as a pure role=2 tool-call message (no text attached)
+            for (const tc of toolCalls) {
+                const argumentsJson = typeof tc.input === "string"
+                    ? tc.input
+                    : JSON.stringify(tc.input);
+                result.push({
+                    role: 2,
+                    toolCall: { id: tc.toolCallId, name: tc.toolName, argumentsJson },
+                });
+            }
+            continue;
+        }
+        if (msg.role === "tool") {
+            const parts = msg.content;
+            for (const tr of parts) {
+                if (tr.type !== "tool-result")
+                    continue;
+                result.push({
+                    role: 4,
+                    content: extractToolOutput(tr.output),
+                    toolResult: { toolCallId: tr.toolCallId },
+                });
+            }
+            continue;
+        }
+    }
+    return result;
+}
+function convertTools(options) {
+    const tools = options.tools;
+    if (!tools)
+        return [];
+    return tools
+        .filter((t) => t.type === "function")
+        .map((t) => {
+        const ft = t;
+        return {
+            name: ft.name,
+            description: ft.description ?? ft.name,
+            parametersJsonSchema: JSON.stringify(ft.inputSchema),
+        };
+    });
+}
+async function streamViaDirectConnect(controller, options, modelId, tracker, signal) {
+    if (signal?.aborted)
+        return false;
+    const jwt = await loadWindsurfJwt();
+    if (!jwt)
+        return false;
+    const systemPrompt = extractSystemPrompt(options);
+    const messages = convertToProtoMessages(options);
+    const tools = convertTools(options);
+    const body = encodeGetChatMessageRequest({
+        jwt,
+        systemPrompt,
+        messages,
+        tools,
+        modelId,
+    });
+    let reasoningStarted = false;
+    let textStarted = false;
+    let finished = false;
+    const toolCalls = new Map();
+    let toolCallStarted = false;
+    const events = streamGetChatMessage(body, signal);
+    function flushToolCall(id) {
+        const tc = toolCalls.get(id);
+        if (!tc)
+            return;
+        toolCalls.delete(id);
+        const input = tc.argsChunks.join("");
+        controller.enqueue({ type: "tool-input-end", id });
+        controller.enqueue({ type: "tool-call", toolCallId: id, toolName: tc.name, input });
+        trackContent(tracker, "tool-call");
+    }
+    function flushAllToolCalls() {
+        for (const id of toolCalls.keys()) {
+            flushToolCall(id);
+        }
+        toolCallStarted = false;
+    }
+    try {
+        for await (const event of events) {
+            if (finished)
+                break;
+            switch (event.type) {
+                case "reasoning": {
+                    if (!reasoningStarted) {
+                        controller.enqueue({ type: "reasoning-start", id: "0" });
+                        trackContent(tracker, "reasoning-start");
+                        reasoningStarted = true;
+                    }
+                    controller.enqueue({ type: "reasoning-delta", id: "0", delta: event.delta });
+                    trackContent(tracker, "reasoning-delta");
+                    break;
+                }
+                case "text": {
+                    if (reasoningStarted) {
+                        controller.enqueue({ type: "reasoning-end", id: "0" });
+                        reasoningStarted = false;
+                    }
+                    if (!textStarted) {
+                        controller.enqueue({ type: "text-start", id: "1" });
+                        trackContent(tracker, "text-start");
+                        textStarted = true;
+                    }
+                    controller.enqueue({ type: "text-delta", id: "1", delta: event.delta });
+                    trackContent(tracker, "text-delta");
+                    break;
+                }
+                case "tool-call-start": {
+                    // close any prior text/reasoning stream
+                    if (reasoningStarted) {
+                        controller.enqueue({ type: "reasoning-end", id: "0" });
+                        reasoningStarted = false;
+                    }
+                    if (textStarted) {
+                        controller.enqueue({ type: "text-end", id: "1" });
+                        textStarted = false;
+                    }
+                    // flush any previous incomplete tool call
+                    flushAllToolCalls();
+                    // start new tool call
+                    toolCalls.set(event.id, { name: event.name, argsChunks: [] });
+                    controller.enqueue({ type: "tool-input-start", id: event.id, toolName: event.name });
+                    trackContent(tracker, "tool-input-start");
+                    toolCallStarted = true;
+                    break;
+                }
+                case "tool-call-delta": {
+                    const tc = toolCalls.get(event.id);
+                    if (tc) {
+                        tc.argsChunks.push(event.argsChunk);
+                    }
+                    controller.enqueue({ type: "tool-input-delta", id: event.id, delta: event.argsChunk });
+                    break;
+                }
+                case "finish": {
+                    finished = true;
+                    if (reasoningStarted) {
+                        controller.enqueue({ type: "reasoning-end", id: "0" });
+                        reasoningStarted = false;
+                    }
+                    if (textStarted) {
+                        controller.enqueue({ type: "text-end", id: "1" });
+                        textStarted = false;
+                    }
+                    // flush any pending tool calls
+                    flushAllToolCalls();
+                    const isToolUse = event.stopReason === 10;
+                    const usage = {
+                        inputTokens: {
+                            total: event.inputTokens,
+                            noCache: undefined,
+                            cacheRead: undefined,
+                            cacheWrite: undefined,
+                        },
+                        outputTokens: {
+                            total: event.outputTokens,
+                            text: event.outputTokens,
+                            reasoning: undefined,
+                        },
+                    };
+                    controller.enqueue({
+                        type: "finish",
+                        finishReason: isToolUse ? TOOL_CALLS_REASON : STOP_REASON,
+                        usage,
+                    });
+                    break;
+                }
+            }
+        }
+    }
+    catch {
+        return false;
+    }
+    if (!finished) {
+        if (reasoningStarted)
+            controller.enqueue({ type: "reasoning-end", id: "0" });
+        if (textStarted)
+            controller.enqueue({ type: "text-end", id: "1" });
+        flushAllToolCalls();
+        controller.enqueue({ type: "finish", finishReason: STOP_REASON, usage: ZERO_USAGE });
+    }
+    if (!tracker.emitted) {
+        controller.enqueue({ type: "error", error: EMPTY_RESULT_ERROR });
+    }
+    controller.close();
+    return true;
+}
+// ── Fallback: devin -p path ──────────────────────────────────────────────────
+async function fallbackDevinRun(modelId, prompt) {
+    const proc = Bun.spawn([getDevinPath(), "--permission-mode", "bypass", "--model", modelId, "-p", "--", prompt], {
+        stdout: "pipe",
+        stderr: "pipe",
+    });
+    const output = await new Response(proc.stdout).text();
+    const stderr = await new Response(proc.stderr).text();
+    const exitCode = await proc.exited;
+    return { output, exitCode, stderr };
+}
+async function doGenerateViaFallback(options, modelId) {
+    const prompt = flattenHistory(options);
+    const { output, exitCode, stderr } = await fallbackDevinRun(modelId, prompt);
+    if (exitCode !== 0) {
+        throw new Error(`devin exited with code ${exitCode}: ${stderr.slice(0, 500)}`);
+    }
+    return {
+        content: [{ type: "text", text: stripDevinBanner(output) }],
+        finishReason: STOP_REASON,
+        usage: ZERO_USAGE,
+        warnings: [],
+    };
+}
+// ── Proxy streaming path (best-effort reasoning enrichment) ─────────────────
+async function streamViaProxy(controller, events, tracker) {
+    let reasoningStarted = false;
+    let textStarted = false;
+    let finished = false;
+    try {
+        for await (const event of events) {
+            if (finished)
+                break;
+            switch (event.type) {
+                case "reasoning": {
+                    const t = event.text;
+                    if (!reasoningStarted) {
+                        controller.enqueue({ type: "reasoning-start", id: "0" });
+                        trackContent(tracker, "reasoning-start");
+                        reasoningStarted = true;
+                    }
+                    controller.enqueue({ type: "reasoning-delta", id: "0", delta: t });
+                    trackContent(tracker, "reasoning-delta");
+                    break;
+                }
+                case "text": {
+                    const t = event.text;
+                    if (reasoningStarted) {
+                        controller.enqueue({ type: "reasoning-end", id: "0" });
+                        reasoningStarted = false;
+                    }
+                    if (!textStarted) {
+                        controller.enqueue({ type: "text-start", id: "1" });
+                        trackContent(tracker, "text-start");
+                        textStarted = true;
+                    }
+                    controller.enqueue({ type: "text-delta", id: "1", delta: t });
+                    trackContent(tracker, "text-delta");
+                    break;
+                }
+                case "finish": {
+                    finished = true;
+                    const f = event;
+                    if (reasoningStarted) {
+                        controller.enqueue({ type: "reasoning-end", id: "0" });
+                        reasoningStarted = false;
+                    }
+                    if (textStarted) {
+                        controller.enqueue({ type: "text-end", id: "1" });
+                        textStarted = false;
+                    }
+                    const usage = {
+                        inputTokens: {
+                            total: f.input_tokens,
+                            noCache: undefined,
+                            cacheRead: undefined,
+                            cacheWrite: undefined,
+                        },
+                        outputTokens: {
+                            total: f.output_tokens,
+                            text: f.output_tokens,
+                            reasoning: undefined,
+                        },
+                    };
+                    controller.enqueue({ type: "finish", finishReason: STOP_REASON, usage });
+                    break;
+                }
+            }
+        }
+    }
+    catch {
+        return false;
+    }
+    // If we never got a finish event, emit one with zero usage
+    if (!finished) {
+        if (reasoningStarted)
+            controller.enqueue({ type: "reasoning-end", id: "0" });
+        if (textStarted)
+            controller.enqueue({ type: "text-end", id: "1" });
+        controller.enqueue({ type: "finish", finishReason: STOP_REASON, usage: ZERO_USAGE });
+    }
+    if (!tracker.emitted) {
+        controller.enqueue({ type: "error", error: EMPTY_RESULT_ERROR });
+    }
+    controller.close();
+    return true;
+}
+// ── Fallback: direct devin -p word-split (no reasoning) ─────────────────────
+async function streamViaFallback(controller, modelId, text, tracker, signal) {
+    if (signal?.aborted) {
+        controller.enqueue({ type: "error", error: EMPTY_RESULT_ERROR });
+        controller.enqueue({ type: "finish", finishReason: ERROR_REASON, usage: ZERO_USAGE });
+        controller.close();
+        return;
+    }
+    const proc = Bun.spawn([getDevinPath(), "--permission-mode", "bypass", "--model", modelId, "-p", "--", text], {
+        stdout: "pipe",
+        stderr: "pipe",
+        signal,
+    });
+    const output = await new Response(proc.stdout).text();
+    const stripped = stripDevinBanner(output);
+    const wordPattern = /\S+\s*/g;
+    const words = stripped.match(wordPattern) ?? [];
+    controller.enqueue({ type: "text-start", id: "0" });
+    trackContent(tracker, "text-start");
+    for (const word of words) {
+        controller.enqueue({ type: "text-delta", id: "0", delta: word });
+        trackContent(tracker, "text-delta");
+    }
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+        const stderr = await new Response(proc.stderr).text();
+        controller.enqueue({ type: "error", error: new Error(`devin exit ${exitCode}: ${stderr.slice(0, 200)}`) });
+        controller.enqueue({ type: "finish", finishReason: ERROR_REASON, usage: ZERO_USAGE });
+        controller.close();
+        return;
+    }
+    controller.enqueue({ type: "text-end", id: "0" });
+    controller.enqueue({ type: "finish", finishReason: STOP_REASON, usage: ZERO_USAGE });
+    if (!tracker.emitted) {
+        controller.enqueue({ type: "error", error: EMPTY_RESULT_ERROR });
+    }
+    controller.close();
+}
+// ── Model class ──────────────────────────────────────────────────────────────
+export class WindsurfLanguageModel {
+    specificationVersion = "v3";
+    provider;
+    modelId;
+    supportedUrls = {};
+    constructor(modelId) {
+        this.provider = "windsurf";
+        this.modelId = modelId;
+    }
+    async doGenerate(options) {
+        return doGenerateViaFallback(options, this.modelId);
+    }
+    async doStream(options) {
+        const text = flattenHistory(options);
+        const modelId = this.modelId;
+        const stream = new ReadableStream({
+            async start(controller) {
+                const tracker = { emitted: false };
+                // Combined abort signal: internal timeout + external signal from caller
+                const timeoutAc = new AbortController();
+                const timeoutId = setTimeout(() => timeoutAc.abort(new Error("Stream timeout")), STREAM_TIMEOUT_MS);
+                const externalSignal = options.abortSignal;
+                const onExternalAbort = () => {
+                    clearTimeout(timeoutId);
+                    timeoutAc.abort(externalSignal?.reason);
+                };
+                if (externalSignal) {
+                    if (externalSignal.aborted) {
+                        clearTimeout(timeoutId);
+                        timeoutAc.abort(externalSignal.reason);
+                    }
+                    externalSignal.addEventListener("abort", onExternalAbort, { once: true });
+                }
+                try {
+                    controller.enqueue({ type: "stream-start", warnings: [] });
+                    // Level-2: direct Connect-RPC to Windsurf API (with tools)
+                    const directSuccess = await streamViaDirectConnect(controller, options, modelId, tracker, timeoutAc.signal);
+                    if (directSuccess)
+                        return;
+                    // Try proxy path first (best-effort reasoning enrichment)
+                    const proxyStream = await launchProxyStream(modelId, text);
+                    if (proxyStream.ok) {
+                        const success = await streamViaProxy(controller, proxyStream.events, tracker);
+                        await proxyStream.cleanup();
+                        if (success)
+                            return;
+                    }
+                    // Fallback: direct devin -p word-split (no reasoning)
+                    await streamViaFallback(controller, modelId, text, tracker, timeoutAc.signal);
+                }
+                finally {
+                    clearTimeout(timeoutId);
+                    if (externalSignal) {
+                        externalSignal.removeEventListener("abort", onExternalAbort);
+                    }
+                }
+            },
+        });
+        return { stream };
+    }
+}
+export function createWindsurf(opts) {
+    return {
+        languageModel(modelId) {
+            return new WindsurfLanguageModel(modelId);
+        },
+    };
+}
+export * as WindsurfProvider from ".";

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@ngotrnghia1811/opencode-windsurf-auth",
+  "version": "0.1.0",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": ["opencode", "windsurf", "llm", "provider", "plugin", "ai"],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ngotrnghia1811/opencode-windsurf-auth"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "dependencies": {},
+  "devDependencies": {
+    "@ai-sdk/provider": "3.0.8",
+    "@opencode-ai/plugin": "1.14.50",
+    "@opencode-ai/sdk": "1.15.12",
+    "@tsconfig/bun": "1.0.10",
+    "@types/bun": "1.3.14",
+    "typescript": "6.0.3"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": "*"
+  },
+  "description": "OpenCode plugin — Level-2 Connect-RPC provider for Windsurf/Cascade models via Devin CLI credentials",
+  "engines": {
+    "bun": "1.3.14"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "prepare": "tsc -p tsconfig.build.json",
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc",
+    "test": "bun test",
+    "dev": "bun scripts/dev.ts"
+  }
+}