opencode-cursor-oauth 0.0.1

package/dist/proxy.js

@@ -0,0 +1,992 @@
+/**
+ * Local OpenAI-compatible proxy that translates requests to Cursor's gRPC protocol.
+ *
+ * Accepts POST /v1/chat/completions in OpenAI format, translates to Cursor's
+ * protobuf/HTTP2 Connect protocol, and streams back OpenAI-format SSE.
+ *
+ * Tool calling uses Cursor's native MCP tool protocol:
+ * - OpenAI tool defs → McpToolDefinition in RequestContext
+ * - Cursor toolCallStarted/Delta/Completed → OpenAI tool_calls SSE chunks
+ * - mcpArgs exec → pause stream, return tool_calls to caller
+ * - Follow-up request with tool results → resume bridge with mcpResult
+ *
+ * HTTP/2 transport is delegated to a Node child process (h2-bridge.mjs)
+ * because Bun's node:http2 module is broken.
+ */
+import { create, fromBinary, fromJson, toBinary, toJson } from "@bufbuild/protobuf";
+import { ValueSchema } from "@bufbuild/protobuf/wkt";
+import { AgentClientMessageSchema, AgentRunRequestSchema, AgentServerMessageSchema, ClientHeartbeatSchema, ConversationActionSchema, ConversationStateStructureSchema, ConversationStepSchema, AgentConversationTurnStructureSchema, ConversationTurnStructureSchema, AssistantMessageSchema, BackgroundShellSpawnResultSchema, DeleteResultSchema, DeleteRejectedSchema, DiagnosticsResultSchema, ExecClientMessageSchema, FetchErrorSchema, FetchResultSchema, GetBlobResultSchema, GrepErrorSchema, GrepResultSchema, KvClientMessageSchema, LsRejectedSchema, LsResultSchema, McpErrorSchema, McpResultSchema, McpSuccessSchema, McpTextContentSchema, McpToolDefinitionSchema, McpToolResultContentItemSchema, ModelDetailsSchema, ReadRejectedSchema, ReadResultSchema, RequestContextResultSchema, RequestContextSchema, RequestContextSuccessSchema, SetBlobResultSchema, ShellRejectedSchema, ShellResultSchema, UserMessageActionSchema, UserMessageSchema, WriteRejectedSchema, WriteResultSchema, WriteShellStdinErrorSchema, WriteShellStdinResultSchema, } from "./proto/agent_pb";
+import { createHash } from "node:crypto";
+import { resolve as pathResolve } from "node:path";
+const CURSOR_API_URL = "https://api2.cursor.sh";
+const CONNECT_END_STREAM_FLAG = 0b00000010;
+const BRIDGE_PATH = pathResolve(import.meta.dir, "h2-bridge.mjs");
+// Active bridges keyed by a session token (derived from conversation state).
+// When tool_calls are returned, the bridge stays alive. The next request
+// with tool results looks up the bridge and sends mcpResult messages.
+const activeBridges = new Map();
+// --- H2 Bridge IPC ---
+/** Length-prefix a message: [4-byte BE length][payload] */
+function lpEncode(data) {
+    const buf = Buffer.alloc(4 + data.length);
+    buf.writeUInt32BE(data.length, 0);
+    buf.set(data, 4);
+    return buf;
+}
+/** Connect protocol frame: [1-byte flags][4-byte BE length][payload] */
+function frameConnectMessage(data, flags = 0) {
+    const frame = Buffer.alloc(5 + data.length);
+    frame[0] = flags;
+    frame.writeUInt32BE(data.length, 1);
+    frame.set(data, 5);
+    return frame;
+}
+/**
+ * Spawn the Node H2 bridge and return read/write handles.
+ * The bridge uses length-prefixed framing on stdin/stdout.
+ */
+function spawnBridge(accessToken) {
+    const proc = Bun.spawn(["node", BRIDGE_PATH], {
+        stdin: "pipe",
+        stdout: "pipe",
+        stderr: "ignore",
+    });
+    const config = JSON.stringify({
+        accessToken,
+        url: CURSOR_API_URL,
+        path: "/agent.v1.AgentService/Run",
+    });
+    proc.stdin.write(lpEncode(new TextEncoder().encode(config)));
+    const cbs = {
+        data: null,
+        close: null,
+    };
+    (async () => {
+        const reader = proc.stdout.getReader();
+        let pending = Buffer.alloc(0);
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                pending = Buffer.concat([pending, Buffer.from(value)]);
+                while (pending.length >= 4) {
+                    const len = pending.readUInt32BE(0);
+                    if (pending.length < 4 + len)
+                        break;
+                    const payload = pending.subarray(4, 4 + len);
+                    pending = pending.subarray(4 + len);
+                    cbs.data?.(Buffer.from(payload));
+                }
+            }
+        }
+        catch {
+            // Stream ended
+        }
+        proc.exited.then((code) => cbs.close?.(code ?? 1));
+    })();
+    return {
+        proc,
+        write(data) {
+            try {
+                proc.stdin.write(lpEncode(data));
+            }
+            catch { }
+        },
+        end() {
+            try {
+                proc.stdin.write(lpEncode(new Uint8Array(0)));
+                proc.stdin.end();
+            }
+            catch { }
+        },
+        onData(cb) { cbs.data = cb; },
+        onClose(cb) { cbs.close = cb; },
+    };
+}
+// --- Proxy Server ---
+let proxyServer;
+let proxyPort;
+export function getProxyPort() {
+    return proxyPort;
+}
+export async function startProxy(getAccessToken) {
+    if (proxyServer && proxyPort)
+        return proxyPort;
+    proxyServer = Bun.serve({
+        port: 0,
+        idleTimeout: 255, // max — Cursor responses can take 30s+
+        async fetch(req) {
+            const url = new URL(req.url);
+            if (req.method === "GET" && url.pathname === "/v1/models") {
+                return new Response(JSON.stringify({ object: "list", data: [] }), { headers: { "Content-Type": "application/json" } });
+            }
+            if (req.method === "POST" && url.pathname === "/v1/chat/completions") {
+                try {
+                    const body = (await req.json());
+                    const accessToken = await getAccessToken();
+                    return handleChatCompletion(body, accessToken);
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    return new Response(JSON.stringify({
+                        error: { message, type: "server_error", code: "internal_error" },
+                    }), { status: 500, headers: { "Content-Type": "application/json" } });
+                }
+            }
+            return new Response("Not Found", { status: 404 });
+        },
+    });
+    proxyPort = proxyServer.port;
+    if (!proxyPort)
+        throw new Error("Failed to bind proxy to a port");
+    return proxyPort;
+}
+export function stopProxy() {
+    if (proxyServer) {
+        proxyServer.stop();
+        proxyServer = undefined;
+        proxyPort = undefined;
+    }
+    // Clean up any lingering bridges
+    for (const [key, active] of activeBridges) {
+        clearInterval(active.heartbeatTimer);
+        active.bridge.end();
+        activeBridges.delete(key);
+    }
+}
+// --- Chat Completion Handler ---
+function handleChatCompletion(body, accessToken) {
+    const { systemPrompt, userText, turns, toolResults } = parseMessages(body.messages);
+    const modelId = body.model;
+    const tools = body.tools ?? [];
+    if (!userText && toolResults.length === 0) {
+        return new Response(JSON.stringify({
+            error: {
+                message: "No user message found",
+                type: "invalid_request_error",
+            },
+        }), { status: 400, headers: { "Content-Type": "application/json" } });
+    }
+    // Check for an active bridge waiting for tool results
+    const bridgeKey = deriveBridgeKey(modelId, body.messages);
+    const activeBridge = activeBridges.get(bridgeKey);
+    if (activeBridge && toolResults.length > 0) {
+        // Resume an existing bridge with tool results
+        activeBridges.delete(bridgeKey);
+        return handleToolResultResume(activeBridge, toolResults, modelId, tools, accessToken, bridgeKey);
+    }
+    // Clean up stale bridge if present
+    if (activeBridge) {
+        clearInterval(activeBridge.heartbeatTimer);
+        activeBridge.bridge.end();
+        activeBridges.delete(bridgeKey);
+    }
+    const mcpTools = buildMcpToolDefinitions(tools);
+    const payload = buildCursorRequest(modelId, systemPrompt, userText, turns);
+    payload.mcpTools = mcpTools;
+    if (body.stream === false) {
+        return handleNonStreamingResponse(payload, accessToken, modelId);
+    }
+    return handleStreamingResponse(payload, accessToken, modelId, bridgeKey);
+}
+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")
+        .map((m) => m.content ?? "");
+    if (systemParts.length > 0) {
+        systemPrompt = systemParts.join("\n");
+    }
+    // Separate tool results from conversation turns
+    const nonSystem = messages.filter((m) => m.role !== "system");
+    let pendingUser = "";
+    for (const msg of nonSystem) {
+        if (msg.role === "tool") {
+            toolResults.push({
+                toolCallId: msg.tool_call_id ?? "",
+                content: msg.content ?? "",
+            });
+        }
+        else if (msg.role === "user") {
+            if (pendingUser) {
+                pairs.push({ userText: pendingUser, assistantText: "" });
+            }
+            pendingUser = msg.content ?? "";
+        }
+        else if (msg.role === "assistant") {
+            // Skip assistant messages that are just tool_calls with no text
+            const text = msg.content ?? "";
+            if (pendingUser) {
+                pairs.push({ userText: pendingUser, assistantText: text });
+                pendingUser = "";
+            }
+        }
+    }
+    let lastUserText = "";
+    if (pendingUser) {
+        lastUserText = pendingUser;
+    }
+    else if (pairs.length > 0 && toolResults.length === 0) {
+        const last = pairs.pop();
+        lastUserText = last.userText;
+    }
+    return { systemPrompt, userText: lastUserText, turns: pairs, toolResults };
+}
+// --- MCP Tool Definitions ---
+/** Convert OpenAI tool definitions to Cursor's MCP tool protobuf format. */
+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. */
+function decodeMcpArgsMap(args) {
+    const decoded = {};
+    for (const [key, value] of Object.entries(args)) {
+        decoded[key] = decodeMcpArgValue(value);
+    }
+    return decoded;
+}
+// --- gRPC Request Building ---
+function buildCursorRequest(modelId, systemPrompt, userText, turns) {
+    const blobStore = new Map();
+    const turnBytes = [];
+    for (const turn of turns) {
+        const userMsg = create(UserMessageSchema, {
+            text: turn.userText,
+            messageId: crypto.randomUUID(),
+        });
+        const userMsgBytes = toBinary(UserMessageSchema, userMsg);
+        const stepBytes = [];
+        if (turn.assistantText) {
+            const step = create(ConversationStepSchema, {
+                message: {
+                    case: "assistantMessage",
+                    value: create(AssistantMessageSchema, { text: turn.assistantText }),
+                },
+            });
+            stepBytes.push(toBinary(ConversationStepSchema, step));
+        }
+        const agentTurn = create(AgentConversationTurnStructureSchema, {
+            userMessage: userMsgBytes,
+            steps: stepBytes,
+        });
+        const turnStructure = create(ConversationTurnStructureSchema, {
+            turn: { case: "agentConversationTurn", value: agentTurn },
+        });
+        turnBytes.push(toBinary(ConversationTurnStructureSchema, turnStructure));
+    }
+    // System prompt → blob store (Cursor requests it back via KV handshake)
+    const systemJson = JSON.stringify({ role: "system", content: systemPrompt });
+    const systemBytes = new TextEncoder().encode(systemJson);
+    const systemBlobId = new Uint8Array(createHash("sha256").update(systemBytes).digest());
+    blobStore.set(Buffer.from(systemBlobId).toString("hex"), systemBytes);
+    const conversationState = create(ConversationStateStructureSchema, {
+        rootPromptMessagesJson: [systemBlobId],
+        turns: turnBytes,
+        todos: [],
+        pendingToolCalls: [],
+        previousWorkspaceUris: [],
+        fileStates: {},
+        fileStatesV2: {},
+        summaryArchives: [],
+        turnTimings: [],
+        subagentStates: {},
+        selfSummaryCount: 0,
+        readPaths: [],
+    });
+    const userMessage = create(UserMessageSchema, {
+        text: userText,
+        messageId: crypto.randomUUID(),
+    });
+    const action = create(ConversationActionSchema, {
+        action: {
+            case: "userMessageAction",
+            value: create(UserMessageActionSchema, { userMessage }),
+        },
+    });
+    const modelDetails = create(ModelDetailsSchema, {
+        modelId,
+        displayModelId: modelId,
+        displayName: modelId,
+    });
+    const runRequest = create(AgentRunRequestSchema, {
+        conversationState,
+        action,
+        modelDetails,
+        conversationId: crypto.randomUUID(),
+    });
+    const clientMessage = create(AgentClientMessageSchema, {
+        message: { case: "runRequest", value: runRequest },
+    });
+    return {
+        requestBytes: toBinary(AgentClientMessageSchema, clientMessage),
+        blobStore,
+        mcpTools: [],
+    };
+}
+// --- Connect Protocol Helpers ---
+function parseConnectEndStream(data) {
+    try {
+        const payload = JSON.parse(new TextDecoder().decode(data));
+        const error = payload?.error;
+        if (error) {
+            const code = typeof error.code === "string" ? error.code : "unknown";
+            const message = typeof error.message === "string" ? error.message : "Unknown error";
+            return new Error(`Connect error ${code}: ${message}`);
+        }
+        return null;
+    }
+    catch {
+        return new Error("Failed to parse Connect end stream");
+    }
+}
+function makeHeartbeatBytes() {
+    const heartbeat = create(AgentClientMessageSchema, {
+        message: {
+            case: "clientHeartbeat",
+            value: create(ClientHeartbeatSchema, {}),
+        },
+    });
+    return frameConnectMessage(toBinary(AgentClientMessageSchema, heartbeat));
+}
+function processServerMessage(msg, blobStore, mcpTools, sendFrame, state, onText, onMcpExec) {
+    const msgCase = msg.message.case;
+    if (msgCase === "interactionUpdate") {
+        handleInteractionUpdate(msg.message.value, onText);
+    }
+    else if (msgCase === "kvServerMessage") {
+        handleKvMessage(msg.message.value, blobStore, sendFrame);
+    }
+    else if (msgCase === "execServerMessage") {
+        handleExecMessage(msg.message.value, mcpTools, sendFrame, onMcpExec);
+    }
+}
+/**
+ * Handle interaction updates — text and thinking only.
+ * MCP tool calls are handled entirely via mcpArgs exec messages,
+ * not through interaction update callbacks.
+ */
+function handleInteractionUpdate(update, onText) {
+    const updateCase = update.message?.case;
+    if (updateCase === "textDelta") {
+        const delta = update.message.value.text || "";
+        if (delta)
+            onText(delta, false);
+    }
+    else if (updateCase === "thinkingDelta") {
+        const delta = update.message.value.text || "";
+        if (delta)
+            onText(delta, true);
+    }
+    // toolCallStarted, partialToolCall, toolCallDelta, toolCallCompleted
+    // are intentionally ignored. MCP tool calls flow through the exec
+    // message path (mcpArgs → mcpResult), not interaction updates.
+}
+function handleKvMessage(kvMsg, blobStore, sendFrame) {
+    const kvCase = kvMsg.message.case;
+    if (kvCase === "getBlobArgs") {
+        const blobId = kvMsg.message.value.blobId;
+        const blobIdKey = Buffer.from(blobId).toString("hex");
+        const blobData = blobStore.get(blobIdKey);
+        const response = create(KvClientMessageSchema, {
+            id: kvMsg.id,
+            message: {
+                case: "getBlobResult",
+                value: create(GetBlobResultSchema, blobData ? { blobData } : {}),
+            },
+        });
+        const clientMsg = create(AgentClientMessageSchema, {
+            message: { case: "kvClientMessage", value: response },
+        });
+        sendFrame(frameConnectMessage(toBinary(AgentClientMessageSchema, clientMsg)));
+    }
+    else if (kvCase === "setBlobArgs") {
+        const { blobId, blobData } = kvMsg.message.value;
+        blobStore.set(Buffer.from(blobId).toString("hex"), blobData);
+        const response = create(KvClientMessageSchema, {
+            id: kvMsg.id,
+            message: {
+                case: "setBlobResult",
+                value: create(SetBlobResultSchema, {}),
+            },
+        });
+        const clientMsg = create(AgentClientMessageSchema, {
+            message: { case: "kvClientMessage", value: response },
+        });
+        sendFrame(frameConnectMessage(toBinary(AgentClientMessageSchema, clientMsg)));
+    }
+}
+function handleExecMessage(execMsg, mcpTools, sendFrame, onMcpExec) {
+    const execCase = execMsg.message.case;
+    if (execCase === "requestContextArgs") {
+        const requestContext = create(RequestContextSchema, {
+            rules: [],
+            repositoryInfo: [],
+            tools: mcpTools,
+            gitRepos: [],
+            projectLayouts: [],
+            mcpInstructions: [],
+            fileContents: {},
+            customSubagents: [],
+        });
+        const result = create(RequestContextResultSchema, {
+            result: {
+                case: "success",
+                value: create(RequestContextSuccessSchema, { requestContext }),
+            },
+        });
+        sendExecResult(execMsg, "requestContextResult", result, sendFrame);
+        return;
+    }
+    if (execCase === "mcpArgs") {
+        const mcpArgs = execMsg.message.value;
+        const decoded = decodeMcpArgsMap(mcpArgs.args ?? {});
+        onMcpExec({
+            execId: execMsg.execId,
+            execMsgId: execMsg.id,
+            toolCallId: mcpArgs.toolCallId || crypto.randomUUID(),
+            toolName: mcpArgs.toolName || mcpArgs.name,
+            decodedArgs: JSON.stringify(decoded),
+        });
+        return;
+    }
+    // --- Reject native Cursor tools ---
+    // The model tries these first. We must respond with rejection/error
+    // so it falls back to our MCP tools (registered via RequestContext).
+    const REJECT_REASON = "Tool not available in this environment. Use the MCP tools provided instead.";
+    if (execCase === "readArgs") {
+        const args = execMsg.message.value;
+        const result = create(ReadResultSchema, {
+            result: { case: "rejected", value: create(ReadRejectedSchema, { path: args.path, reason: REJECT_REASON }) },
+        });
+        sendExecResult(execMsg, "readResult", result, sendFrame);
+        return;
+    }
+    if (execCase === "lsArgs") {
+        const args = execMsg.message.value;
+        const result = create(LsResultSchema, {
+            result: { case: "rejected", value: create(LsRejectedSchema, { path: args.path, reason: REJECT_REASON }) },
+        });
+        sendExecResult(execMsg, "lsResult", result, sendFrame);
+        return;
+    }
+    if (execCase === "grepArgs") {
+        const result = create(GrepResultSchema, {
+            result: { case: "error", value: create(GrepErrorSchema, { error: REJECT_REASON }) },
+        });
+        sendExecResult(execMsg, "grepResult", result, sendFrame);
+        return;
+    }
+    if (execCase === "writeArgs") {
+        const args = execMsg.message.value;
+        const result = create(WriteResultSchema, {
+            result: { case: "rejected", value: create(WriteRejectedSchema, { path: args.path, reason: REJECT_REASON }) },
+        });
+        sendExecResult(execMsg, "writeResult", result, sendFrame);
+        return;
+    }
+    if (execCase === "deleteArgs") {
+        const args = execMsg.message.value;
+        const result = create(DeleteResultSchema, {
+            result: { case: "rejected", value: create(DeleteRejectedSchema, { path: args.path, reason: REJECT_REASON }) },
+        });
+        sendExecResult(execMsg, "deleteResult", result, sendFrame);
+        return;
+    }
+    if (execCase === "shellArgs" || execCase === "shellStreamArgs") {
+        const args = execMsg.message.value;
+        const result = create(ShellResultSchema, {
+            result: {
+                case: "rejected",
+                value: create(ShellRejectedSchema, {
+                    command: args.command ?? "",
+                    workingDirectory: args.workingDirectory ?? "",
+                    reason: REJECT_REASON,
+                    isReadonly: false,
+                }),
+            },
+        });
+        sendExecResult(execMsg, "shellResult", result, sendFrame);
+        return;
+    }
+    if (execCase === "backgroundShellSpawnArgs") {
+        const args = execMsg.message.value;
+        const result = create(BackgroundShellSpawnResultSchema, {
+            result: {
+                case: "rejected",
+                value: create(ShellRejectedSchema, {
+                    command: args.command ?? "",
+                    workingDirectory: args.workingDirectory ?? "",
+                    reason: REJECT_REASON,
+                    isReadonly: false,
+                }),
+            },
+        });
+        sendExecResult(execMsg, "backgroundShellSpawnResult", result, sendFrame);
+        return;
+    }
+    if (execCase === "writeShellStdinArgs") {
+        const result = create(WriteShellStdinResultSchema, {
+            result: { case: "error", value: create(WriteShellStdinErrorSchema, { error: REJECT_REASON }) },
+        });
+        sendExecResult(execMsg, "writeShellStdinResult", result, sendFrame);
+        return;
+    }
+    if (execCase === "fetchArgs") {
+        const args = execMsg.message.value;
+        const result = create(FetchResultSchema, {
+            result: { case: "error", value: create(FetchErrorSchema, { url: args.url ?? "", error: REJECT_REASON }) },
+        });
+        sendExecResult(execMsg, "fetchResult", result, sendFrame);
+        return;
+    }
+    if (execCase === "diagnosticsArgs") {
+        const result = create(DiagnosticsResultSchema, {});
+        sendExecResult(execMsg, "diagnosticsResult", result, sendFrame);
+        return;
+    }
+    // MCP resource/screen/computer exec types
+    const miscCaseMap = {
+        listMcpResourcesExecArgs: "listMcpResourcesExecResult",
+        readMcpResourceExecArgs: "readMcpResourceExecResult",
+        recordScreenArgs: "recordScreenResult",
+        computerUseArgs: "computerUseResult",
+    };
+    const resultCase = miscCaseMap[execCase];
+    if (resultCase) {
+        sendExecResult(execMsg, resultCase, create(McpResultSchema, {}), sendFrame);
+        return;
+    }
+    // Unknown exec type — log and ignore
+    console.error(`[proxy] unhandled exec: ${execCase}`);
+}
+/** Send an exec client message back to Cursor. */
+function sendExecResult(execMsg, messageCase, value, sendFrame) {
+    const execClientMessage = create(ExecClientMessageSchema, {
+        id: execMsg.id,
+        execId: execMsg.execId,
+        message: { case: messageCase, value: value },
+    });
+    const clientMessage = create(AgentClientMessageSchema, {
+        message: { case: "execClientMessage", value: execClientMessage },
+    });
+    sendFrame(frameConnectMessage(toBinary(AgentClientMessageSchema, clientMessage)));
+}
+// --- Bridge Key ---
+/** Derive a stable key to associate a bridge with a conversation. */
+function deriveBridgeKey(modelId, messages) {
+    // Use a hash of the first user message + model as a stable key.
+    // This is imperfect but sufficient for single-session use.
+    const firstUser = messages.find((m) => m.role === "user")?.content ?? "";
+    return createHash("sha256")
+        .update(`${modelId}:${firstUser.slice(0, 200)}`)
+        .digest("hex")
+        .slice(0, 16);
+}
+// --- Streaming Handler ---
+function handleStreamingResponse(payload, accessToken, modelId, bridgeKey) {
+    const completionId = `chatcmpl-${crypto.randomUUID().replace(/-/g, "").slice(0, 28)}`;
+    const created = Math.floor(Date.now() / 1000);
+    const stream = new ReadableStream({
+        start(controller) {
+            const encoder = new TextEncoder();
+            let closed = false;
+            const sendSSE = (data) => {
+                if (closed)
+                    return;
+                controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}\n\n`));
+            };
+            const sendDone = () => {
+                if (closed)
+                    return;
+                controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+            };
+            const closeController = () => {
+                if (closed)
+                    return;
+                closed = true;
+                controller.close();
+            };
+            const makeChunk = (delta, finishReason = null) => ({
+                id: completionId,
+                object: "chat.completion.chunk",
+                created,
+                model: modelId,
+                choices: [{ index: 0, delta, finish_reason: finishReason }],
+            });
+            const state = {
+                thinkingActive: false,
+                toolCallIndex: 0,
+                pendingExecs: [],
+            };
+            let mcpExecReceived = false;
+            const bridge = spawnBridge(accessToken);
+            bridge.write(frameConnectMessage(payload.requestBytes));
+            const heartbeatTimer = setInterval(() => {
+                bridge.write(makeHeartbeatBytes());
+            }, 5_000);
+            let pendingBuffer = Buffer.alloc(0);
+            const processChunk = (incoming) => {
+                pendingBuffer = Buffer.concat([pendingBuffer, incoming]);
+                while (pendingBuffer.length >= 5) {
+                    const flags = pendingBuffer[0];
+                    const msgLen = pendingBuffer.readUInt32BE(1);
+                    if (pendingBuffer.length < 5 + msgLen)
+                        break;
+                    const messageBytes = pendingBuffer.subarray(5, 5 + msgLen);
+                    pendingBuffer = pendingBuffer.subarray(5 + msgLen);
+                    if (flags & CONNECT_END_STREAM_FLAG) {
+                        const endError = parseConnectEndStream(messageBytes);
+                        if (endError) {
+                            sendSSE(makeChunk({ content: `\n[Error: ${endError.message}]` }));
+                        }
+                        continue;
+                    }
+                    try {
+                        const serverMessage = fromBinary(AgentServerMessageSchema, messageBytes);
+                        processServerMessage(serverMessage, payload.blobStore, payload.mcpTools, (data) => bridge.write(data), state, 
+                        // onText
+                        (text, isThinking) => {
+                            if (isThinking) {
+                                if (!state.thinkingActive) {
+                                    state.thinkingActive = true;
+                                    sendSSE(makeChunk({ role: "assistant", content: "<think>" }));
+                                }
+                                sendSSE(makeChunk({ content: text }));
+                            }
+                            else {
+                                if (state.thinkingActive) {
+                                    state.thinkingActive = false;
+                                    sendSSE(makeChunk({ content: "</think>" }));
+                                }
+                                sendSSE(makeChunk({ content: text }));
+                            }
+                        }, 
+                        // onMcpExec — the model wants to execute a tool.
+                        (exec) => {
+                            state.pendingExecs.push(exec);
+                            mcpExecReceived = true;
+                            // Close thinking if active
+                            if (state.thinkingActive) {
+                                sendSSE(makeChunk({ content: "</think>" }));
+                                state.thinkingActive = false;
+                            }
+                            // Emit tool_calls with decoded arguments
+                            const toolCallIndex = state.toolCallIndex++;
+                            sendSSE(makeChunk({
+                                tool_calls: [{
+                                        index: toolCallIndex,
+                                        id: exec.toolCallId,
+                                        type: "function",
+                                        function: {
+                                            name: exec.toolName,
+                                            arguments: exec.decodedArgs,
+                                        },
+                                    }],
+                            }));
+                            // Keep the bridge alive for tool result continuation.
+                            activeBridges.set(bridgeKey, {
+                                bridge,
+                                heartbeatTimer,
+                                blobStore: payload.blobStore,
+                                mcpTools: payload.mcpTools,
+                                pendingExecs: state.pendingExecs,
+                                onResume: null,
+                            });
+                            sendSSE(makeChunk({}, "tool_calls"));
+                            sendDone();
+                            closeController();
+                        });
+                    }
+                    catch {
+                        // Skip unparseable messages
+                    }
+                }
+            };
+            bridge.onData(processChunk);
+            bridge.onClose(() => {
+                clearInterval(heartbeatTimer);
+                if (!mcpExecReceived) {
+                    // Normal completion — no pending tool calls
+                    if (state.thinkingActive) {
+                        sendSSE(makeChunk({ content: "</think>" }));
+                    }
+                    sendSSE(makeChunk({}, "stop"));
+                    sendDone();
+                    closeController();
+                }
+                // If mcpExecReceived, we already closed the controller in onMcpExec
+            });
+        },
+    });
+    return new Response(stream, {
+        headers: {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+        },
+    });
+}
+// --- Tool Result Resume ---
+/** Resume a paused bridge by sending MCP results and continuing to stream. */
+function handleToolResultResume(active, toolResults, modelId, tools, accessToken, bridgeKey) {
+    const { bridge, heartbeatTimer, blobStore, mcpTools, pendingExecs } = active;
+    // 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);
+        const mcpResult = result
+            ? create(McpResultSchema, {
+                result: {
+                    case: "success",
+                    value: create(McpSuccessSchema, {
+                        content: [
+                            create(McpToolResultContentItemSchema, {
+                                content: {
+                                    case: "text",
+                                    value: create(McpTextContentSchema, { text: result.content }),
+                                },
+                            }),
+                        ],
+                        isError: false,
+                    }),
+                },
+            })
+            : create(McpResultSchema, {
+                result: {
+                    case: "error",
+                    value: create(McpErrorSchema, { error: "Tool result not provided" }),
+                },
+            });
+        const execClientMessage = create(ExecClientMessageSchema, {
+            id: exec.execMsgId,
+            execId: exec.execId,
+            message: {
+                case: "mcpResult",
+                value: mcpResult,
+            },
+        });
+        const clientMessage = create(AgentClientMessageSchema, {
+            message: { case: "execClientMessage", value: execClientMessage },
+        });
+        bridge.write(frameConnectMessage(toBinary(AgentClientMessageSchema, clientMessage)));
+    }
+    // Now stream the continuation response.
+    // Reuse the same bridgeKey so subsequent tool calls can be found by deriveBridgeKey().
+    const completionId = `chatcmpl-${crypto.randomUUID().replace(/-/g, "").slice(0, 28)}`;
+    const created = Math.floor(Date.now() / 1000);
+    const stream = new ReadableStream({
+        start(controller) {
+            const encoder = new TextEncoder();
+            let closed = false;
+            const sendSSE = (data) => {
+                if (closed)
+                    return;
+                controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}\n\n`));
+            };
+            const sendDone = () => {
+                if (closed)
+                    return;
+                controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+            };
+            const closeController = () => {
+                if (closed)
+                    return;
+                closed = true;
+                controller.close();
+            };
+            const makeChunk = (delta, finishReason = null) => ({
+                id: completionId,
+                object: "chat.completion.chunk",
+                created,
+                model: modelId,
+                choices: [{ index: 0, delta, finish_reason: finishReason }],
+            });
+            const state = {
+                thinkingActive: false,
+                toolCallIndex: 0,
+                pendingExecs: [],
+            };
+            let mcpExecReceived = false;
+            let pendingBuffer = Buffer.alloc(0);
+            const processChunk = (incoming) => {
+                pendingBuffer = Buffer.concat([pendingBuffer, incoming]);
+                while (pendingBuffer.length >= 5) {
+                    const flags = pendingBuffer[0];
+                    const msgLen = pendingBuffer.readUInt32BE(1);
+                    if (pendingBuffer.length < 5 + msgLen)
+                        break;
+                    const messageBytes = pendingBuffer.subarray(5, 5 + msgLen);
+                    pendingBuffer = pendingBuffer.subarray(5 + msgLen);
+                    if (flags & CONNECT_END_STREAM_FLAG) {
+                        const endError = parseConnectEndStream(messageBytes);
+                        if (endError) {
+                            sendSSE(makeChunk({ content: `\n[Error: ${endError.message}]` }));
+                        }
+                        continue;
+                    }
+                    try {
+                        const serverMessage = fromBinary(AgentServerMessageSchema, messageBytes);
+                        processServerMessage(serverMessage, blobStore, mcpTools, (data) => bridge.write(data), state, (text, isThinking) => {
+                            if (isThinking) {
+                                if (!state.thinkingActive) {
+                                    state.thinkingActive = true;
+                                    sendSSE(makeChunk({ role: "assistant", content: "<think>" }));
+                                }
+                                sendSSE(makeChunk({ content: text }));
+                            }
+                            else {
+                                if (state.thinkingActive) {
+                                    state.thinkingActive = false;
+                                    sendSSE(makeChunk({ content: "</think>" }));
+                                }
+                                sendSSE(makeChunk({ content: text }));
+                            }
+                        }, (exec) => {
+                            state.pendingExecs.push(exec);
+                            mcpExecReceived = true;
+                            if (state.thinkingActive) {
+                                sendSSE(makeChunk({ content: "</think>" }));
+                                state.thinkingActive = false;
+                            }
+                            const toolCallIndex = state.toolCallIndex++;
+                            sendSSE(makeChunk({
+                                tool_calls: [{
+                                        index: toolCallIndex,
+                                        id: exec.toolCallId,
+                                        type: "function",
+                                        function: {
+                                            name: exec.toolName,
+                                            arguments: exec.decodedArgs,
+                                        },
+                                    }],
+                            }));
+                            activeBridges.set(bridgeKey, {
+                                bridge,
+                                heartbeatTimer,
+                                blobStore,
+                                mcpTools,
+                                pendingExecs: state.pendingExecs,
+                                onResume: null,
+                            });
+                            sendSSE(makeChunk({}, "tool_calls"));
+                            sendDone();
+                            closeController();
+                        });
+                    }
+                    catch {
+                        // Skip
+                    }
+                }
+            };
+            // Re-attach data handler to the existing bridge
+            bridge.onData(processChunk);
+            bridge.onClose(() => {
+                clearInterval(heartbeatTimer);
+                if (!mcpExecReceived) {
+                    if (state.thinkingActive) {
+                        sendSSE(makeChunk({ content: "</think>" }));
+                    }
+                    sendSSE(makeChunk({}, "stop"));
+                    sendDone();
+                    closeController();
+                }
+            });
+        },
+    });
+    return new Response(stream, {
+        headers: {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+        },
+    });
+}
+// --- Non-Streaming Handler ---
+function handleNonStreamingResponse(payload, accessToken, modelId) {
+    const completionId = `chatcmpl-${crypto.randomUUID().replace(/-/g, "").slice(0, 28)}`;
+    const created = Math.floor(Date.now() / 1000);
+    const responsePromise = collectFullResponse(payload, accessToken).then((fullText) => new Response(JSON.stringify({
+        id: completionId,
+        object: "chat.completion",
+        created,
+        model: modelId,
+        choices: [
+            {
+                index: 0,
+                message: { role: "assistant", content: fullText },
+                finish_reason: "stop",
+            },
+        ],
+        usage: {
+            prompt_tokens: 0,
+            completion_tokens: 0,
+            total_tokens: 0,
+        },
+    }), { headers: { "Content-Type": "application/json" } }));
+    return responsePromise;
+}
+async function collectFullResponse(payload, accessToken) {
+    const { promise, resolve } = Promise.withResolvers();
+    let fullText = "";
+    const bridge = spawnBridge(accessToken);
+    bridge.write(frameConnectMessage(payload.requestBytes));
+    const heartbeatTimer = setInterval(() => {
+        bridge.write(makeHeartbeatBytes());
+    }, 5_000);
+    let pendingBuffer = Buffer.alloc(0);
+    const state = {
+        thinkingActive: false,
+        toolCallIndex: 0,
+        pendingExecs: [],
+    };
+    bridge.onData((incoming) => {
+        pendingBuffer = Buffer.concat([pendingBuffer, incoming]);
+        while (pendingBuffer.length >= 5) {
+            const flags = pendingBuffer[0];
+            const msgLen = pendingBuffer.readUInt32BE(1);
+            if (pendingBuffer.length < 5 + msgLen)
+                break;
+            const messageBytes = pendingBuffer.subarray(5, 5 + msgLen);
+            pendingBuffer = pendingBuffer.subarray(5 + msgLen);
+            if (flags & CONNECT_END_STREAM_FLAG)
+                continue;
+            try {
+                const serverMessage = fromBinary(AgentServerMessageSchema, messageBytes);
+                processServerMessage(serverMessage, payload.blobStore, payload.mcpTools, (data) => bridge.write(data), state, (text) => { fullText += text; }, () => { });
+            }
+            catch {
+                // Skip
+            }
+        }
+    });
+    bridge.onClose(() => {
+        clearInterval(heartbeatTimer);
+        resolve(fullText);
+    });
+    return promise;
+}