@kaitranntt/ccs 7.43.0 → 7.44.0-dev.1

package/dist/cursor/cursor-executor.js

@@ -0,0 +1,821 @@
+"use strict";
+/**
+ * Cursor Executor
+ * Handles HTTP/2 requests to Cursor API with protobuf encoding/decoding
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CursorExecutor = void 0;
+const crypto = __importStar(require("crypto"));
+const cursor_protobuf_js_1 = require("./cursor-protobuf.js");
+const cursor_translator_js_1 = require("./cursor-translator.js");
+const cursor_stream_parser_js_1 = require("./cursor-stream-parser.js");
+/** Lazy import http2 */
+let http2Module = null;
+async function getHttp2() {
+    if (http2Module)
+        return http2Module;
+    try {
+        http2Module = await Promise.resolve().then(() => __importStar(require('http2')));
+        return http2Module;
+    }
+    catch (err) {
+        if (process.env.CCS_DEBUG) {
+            console.error('[cursor] http2 module not available, falling back to fetch:', err);
+        }
+        return null;
+    }
+}
+/**
+ * Create error response from JSON error
+ */
+function createErrorResponse(jsonError) {
+    const errorMsg = jsonError?.error?.details?.[0]?.debug?.details?.title ||
+        jsonError?.error?.details?.[0]?.debug?.details?.detail ||
+        jsonError?.error?.message ||
+        'API Error';
+    const isRateLimit = jsonError?.error?.code === 'resource_exhausted';
+    return new Response(JSON.stringify({
+        error: {
+            message: errorMsg,
+            type: isRateLimit ? 'rate_limit_error' : 'api_error',
+            code: jsonError?.error?.details?.[0]?.debug?.error || 'unknown',
+        },
+    }), {
+        status: isRateLimit ? 429 : 400,
+        headers: { 'Content-Type': 'application/json' },
+    });
+}
+class CursorExecutor {
+    constructor() {
+        this.baseUrl = 'https://api2.cursor.sh';
+        this.chatPath = '/aiserver.v1.AiService/StreamChat';
+        this.CURSOR_CLIENT_VERSION = '2.3.41';
+        this.CURSOR_USER_AGENT = 'connect-es/1.6.1';
+    }
+    buildUrl() {
+        return `${this.baseUrl}${this.chatPath}`;
+    }
+    /**
+     * Generate checksum using Jyh cipher (time-based XOR with rolling key seed=165)
+     */
+    generateChecksum(machineId) {
+        const timestamp = Math.floor(Date.now() / 1000000);
+        // JS bitwise shifts wrap modulo 32, so >>40 and >>32 give wrong results.
+        // Use Math.trunc division for upper bytes that exceed 32-bit range.
+        const byteArray = new Uint8Array([
+            Math.trunc(timestamp / 2 ** 40) & 0xff,
+            Math.trunc(timestamp / 2 ** 32) & 0xff,
+            (timestamp >>> 24) & 0xff,
+            (timestamp >>> 16) & 0xff,
+            (timestamp >>> 8) & 0xff,
+            timestamp & 0xff,
+        ]);
+        let t = 165;
+        for (let i = 0; i < byteArray.length; i++) {
+            byteArray[i] = ((byteArray[i] ^ t) + (i % 256)) & 0xff;
+            t = byteArray[i];
+        }
+        const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+        let encoded = '';
+        for (let i = 0; i < byteArray.length; i += 3) {
+            const a = byteArray[i];
+            const b = i + 1 < byteArray.length ? byteArray[i + 1] : 0;
+            const c = i + 2 < byteArray.length ? byteArray[i + 2] : 0;
+            encoded += alphabet[a >> 2];
+            encoded += alphabet[((a & 3) << 4) | (b >> 4)];
+            if (i + 1 < byteArray.length) {
+                encoded += alphabet[((b & 15) << 2) | (c >> 6)];
+            }
+            if (i + 2 < byteArray.length) {
+                encoded += alphabet[c & 63];
+            }
+        }
+        return `${encoded}${machineId}`;
+    }
+    buildHeaders(credentials) {
+        const accessToken = credentials.accessToken;
+        const machineId = credentials.machineId;
+        const ghostMode = credentials.ghostMode !== false;
+        if (!machineId) {
+            throw new Error('Machine ID is required for Cursor API');
+        }
+        const delimIdx = accessToken.indexOf('::');
+        const cleanToken = delimIdx !== -1 ? accessToken.slice(delimIdx + 2) : accessToken;
+        if (!cleanToken) {
+            throw new Error('Access token is empty after parsing');
+        }
+        return {
+            authorization: `Bearer ${cleanToken}`,
+            'connect-accept-encoding': 'gzip',
+            'connect-protocol-version': '1',
+            'content-type': 'application/connect+proto',
+            'user-agent': this.CURSOR_USER_AGENT,
+            'x-amzn-trace-id': `Root=${crypto.randomUUID()}`,
+            'x-client-key': crypto.createHash('sha256').update(cleanToken).digest('hex'),
+            'x-cursor-checksum': this.generateChecksum(machineId),
+            'x-cursor-client-version': this.CURSOR_CLIENT_VERSION,
+            'x-cursor-client-type': 'ide',
+            'x-cursor-client-os': process.platform === 'win32'
+                ? 'windows'
+                : process.platform === 'darwin'
+                    ? 'macos'
+                    : 'linux',
+            'x-cursor-client-arch': process.arch === 'arm64' ? 'aarch64' : 'x64',
+            'x-cursor-client-device-type': 'desktop',
+            'x-cursor-config-version': crypto.randomUUID(),
+            'x-cursor-timezone': Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC',
+            'x-ghost-mode': ghostMode ? 'true' : 'false',
+            'x-request-id': crypto.randomUUID(),
+            'x-session-id': crypto.createHash('sha256').update(cleanToken).digest('hex').substring(0, 36),
+        };
+    }
+    transformRequest(model, body, stream, credentials) {
+        const translatedBody = (0, cursor_translator_js_1.buildCursorRequest)(model, body, stream, credentials);
+        const messages = translatedBody.messages || [];
+        const tools = (translatedBody.tools || body.tools || []);
+        const reasoningEffort = body.reasoning_effort || null;
+        return (0, cursor_protobuf_js_1.generateCursorBody)(messages, model, tools, reasoningEffort);
+    }
+    async makeFetchRequest(url, headers, body, signal) {
+        const response = await fetch(url, {
+            method: 'POST',
+            headers,
+            body,
+            signal,
+        });
+        const responseHeaders = {};
+        response.headers.forEach((value, key) => {
+            responseHeaders[key] = value;
+        });
+        return {
+            status: response.status,
+            headers: responseHeaders,
+            body: Buffer.from(await response.arrayBuffer()),
+        };
+    }
+    async makeHttp2Request(url, headers, body, signal) {
+        const http2 = await getHttp2();
+        if (!http2) {
+            throw new Error('http2 module not available');
+        }
+        return new Promise((resolve, reject) => {
+            const urlObj = new URL(url);
+            const client = http2.connect(`https://${urlObj.host}`);
+            const chunks = [];
+            let responseHeaders = {};
+            client.on('error', (err) => {
+                client.close();
+                reject(err);
+            });
+            const req = client.request({
+                ':method': 'POST',
+                ':path': urlObj.pathname,
+                ':authority': urlObj.host,
+                ':scheme': 'https',
+                ...headers,
+            });
+            req.on('response', (hdrs) => {
+                responseHeaders = hdrs;
+            });
+            req.on('data', (chunk) => {
+                chunks.push(chunk);
+            });
+            req.on('end', () => {
+                client.close();
+                resolve({
+                    status: Number(responseHeaders[':status']) || 500,
+                    headers: responseHeaders,
+                    body: Buffer.concat(chunks),
+                });
+            });
+            req.on('error', (err) => {
+                client.close();
+                reject(err);
+            });
+            if (signal) {
+                const onAbort = () => {
+                    req.close();
+                    client.close();
+                    reject(new Error('Request aborted'));
+                };
+                signal.addEventListener('abort', onAbort, { once: true });
+                const cleanup = () => {
+                    signal.removeEventListener('abort', onAbort);
+                };
+                req.on('end', cleanup);
+                req.on('error', cleanup);
+            }
+            req.write(body);
+            req.end();
+        });
+    }
+    async execute(params) {
+        const { model, body, stream, credentials, signal } = params;
+        const url = this.buildUrl();
+        const headers = this.buildHeaders(credentials);
+        const transformedBody = this.transformRequest(model, body, stream, credentials);
+        try {
+            // Streaming requests use incremental HTTP/2 → SSE pipeline
+            if (stream) {
+                const response = await this.executeStreaming(url, headers, transformedBody, model, body, signal);
+                return { response, url, headers, transformedBody: body };
+            }
+            // Non-streaming: buffer entire response then transform to JSON
+            const http2 = await getHttp2();
+            const response = http2
+                ? await this.makeHttp2Request(url, headers, transformedBody, signal)
+                : await this.makeFetchRequest(url, headers, transformedBody, signal);
+            if (response.status !== 200) {
+                const errorText = response.body?.toString() || 'Unknown error';
+                const errorResponse = new Response(JSON.stringify({
+                    error: {
+                        message: `[${response.status}]: ${errorText}`,
+                        type: 'invalid_request_error',
+                        code: '',
+                    },
+                }), {
+                    status: response.status,
+                    headers: { 'Content-Type': 'application/json' },
+                });
+                return { response: errorResponse, url, headers, transformedBody: body };
+            }
+            const transformedResponse = this.transformProtobufToJSON(response.body, model, body);
+            return { response: transformedResponse, url, headers, transformedBody: body };
+        }
+        catch (error) {
+            const errorResponse = new Response(JSON.stringify({
+                error: {
+                    message: error.message,
+                    type: 'connection_error',
+                    code: '',
+                },
+            }), {
+                status: 500,
+                headers: { 'Content-Type': 'application/json' },
+            });
+            return { response: errorResponse, url, headers, transformedBody: body };
+        }
+    }
+    /**
+     * Execute a streaming request, piping HTTP/2 data events through
+     * StreamingFrameParser for incremental SSE output.
+     * Falls back to buffered transformProtobufToSSE when http2 is unavailable.
+     */
+    async executeStreaming(url, headers, body, model, requestBody, signal) {
+        const http2 = await getHttp2();
+        if (!http2) {
+            const response = await this.makeFetchRequest(url, headers, body, signal);
+            if (response.status !== 200) {
+                const errorText = response.body?.toString() || 'Unknown error';
+                return new Response(JSON.stringify({
+                    error: {
+                        message: `[${response.status}]: ${errorText}`,
+                        type: response.status === 429 ? 'rate_limit_error' : 'invalid_request_error',
+                        code: '',
+                    },
+                }), { status: response.status, headers: { 'Content-Type': 'application/json' } });
+            }
+            return this.transformProtobufToSSE(response.body, model, requestBody);
+        }
+        const responseId = `chatcmpl-cursor-${Date.now()}`;
+        const created = Math.floor(Date.now() / 1000);
+        return new Promise((resolve, reject) => {
+            const urlObj = new URL(url);
+            const client = http2.connect(`https://${urlObj.host}`);
+            client.on('error', (err) => {
+                client.close();
+                reject(err);
+            });
+            const req = client.request({
+                ':method': 'POST',
+                ':path': urlObj.pathname,
+                ':authority': urlObj.host,
+                ':scheme': 'https',
+                ...headers,
+            });
+            // Register abort before response headers arrive so cancellation works at all stages
+            let streamClosed = false;
+            let streamController = null;
+            if (signal) {
+                const onAbort = () => {
+                    streamClosed = true;
+                    // Close the ReadableStream controller so consumers don't hang on reader.read()
+                    if (streamController) {
+                        try {
+                            streamController.close();
+                        }
+                        catch {
+                            /* already closed */
+                        }
+                    }
+                    req.close();
+                    client.close();
+                };
+                signal.addEventListener('abort', onAbort, { once: true });
+                const cleanup = () => signal.removeEventListener('abort', onAbort);
+                req.on('end', cleanup);
+                req.on('error', cleanup);
+            }
+            req.on('response', (hdrs) => {
+                const status = Number(hdrs[':status']) || 500;
+                if (status !== 200) {
+                    const errorChunks = [];
+                    req.on('data', (c) => errorChunks.push(c));
+                    req.on('end', () => {
+                        client.close();
+                        const errorText = Buffer.concat(errorChunks).toString();
+                        resolve(new Response(JSON.stringify({
+                            error: {
+                                message: `[${status}]: ${errorText}`,
+                                type: 'invalid_request_error',
+                                code: '',
+                            },
+                        }), { status, headers: { 'Content-Type': 'application/json' } }));
+                    });
+                    return;
+                }
+                // Status 200: set up incremental streaming pipeline
+                const parser = new cursor_stream_parser_js_1.StreamingFrameParser();
+                const enc = new TextEncoder();
+                const toolCallsMap = new Map();
+                let chunkCount = 0;
+                let toolCallCount = 0;
+                const readable = new ReadableStream({
+                    start(controller) {
+                        streamController = controller;
+                        const emitSSE = (data) => {
+                            if (streamClosed)
+                                return;
+                            controller.enqueue(enc.encode(`data: ${data}\n\n`));
+                        };
+                        const closeStream = () => {
+                            if (streamClosed)
+                                return;
+                            streamClosed = true;
+                            try {
+                                controller.close();
+                            }
+                            catch {
+                                /* already closed */
+                            }
+                            client.close();
+                        };
+                        const buildChunk = (delta, finishReason) => JSON.stringify({
+                            id: responseId,
+                            object: 'chat.completion.chunk',
+                            created,
+                            model,
+                            choices: [{ index: 0, delta, finish_reason: finishReason }],
+                        });
+                        req.on('data', (chunk) => {
+                            if (streamClosed)
+                                return;
+                            for (const frame of parser.push(chunk)) {
+                                if (frame.type === 'error') {
+                                    emitSSE(JSON.stringify({
+                                        error: { message: frame.message, type: frame.errorType, code: '' },
+                                    }));
+                                    emitSSE('[DONE]');
+                                    closeStream();
+                                    return;
+                                }
+                                if (frame.type === 'toolCall') {
+                                    const tc = frame.toolCall;
+                                    // Emit role chunk on first content
+                                    if (chunkCount === 0) {
+                                        emitSSE(buildChunk({ role: 'assistant', content: '' }, null));
+                                        chunkCount++;
+                                    }
+                                    if (toolCallsMap.has(tc.id)) {
+                                        const existing = toolCallsMap.get(tc.id);
+                                        if (!existing)
+                                            continue;
+                                        existing.function.arguments += tc.function.arguments;
+                                        existing.isLast = tc.isLast;
+                                        if (tc.function.arguments) {
+                                            emitSSE(buildChunk({
+                                                tool_calls: [
+                                                    {
+                                                        index: existing.index,
+                                                        id: tc.id,
+                                                        type: 'function',
+                                                        function: {
+                                                            name: tc.function.name,
+                                                            arguments: tc.function.arguments,
+                                                        },
+                                                    },
+                                                ],
+                                            }, null));
+                                            chunkCount++;
+                                        }
+                                    }
+                                    else {
+                                        const idx = toolCallCount++;
+                                        toolCallsMap.set(tc.id, { ...tc, index: idx });
+                                        emitSSE(buildChunk({
+                                            tool_calls: [
+                                                {
+                                                    index: idx,
+                                                    id: tc.id,
+                                                    type: 'function',
+                                                    function: {
+                                                        name: tc.function.name,
+                                                        arguments: tc.function.arguments,
+                                                    },
+                                                },
+                                            ],
+                                        }, null));
+                                        chunkCount++;
+                                    }
+                                }
+                                if (frame.type === 'text') {
+                                    const delta = chunkCount === 0 && toolCallCount === 0
+                                        ? { role: 'assistant', content: frame.text }
+                                        : { content: frame.text };
+                                    emitSSE(buildChunk(delta, null));
+                                    chunkCount++;
+                                }
+                            }
+                        });
+                        req.on('end', () => {
+                            if (streamClosed)
+                                return;
+                            if (chunkCount === 0 && toolCallCount === 0) {
+                                emitSSE(buildChunk({ role: 'assistant', content: '' }, null));
+                            }
+                            emitSSE(JSON.stringify({
+                                id: responseId,
+                                object: 'chat.completion.chunk',
+                                created,
+                                model,
+                                choices: [
+                                    {
+                                        index: 0,
+                                        delta: {},
+                                        finish_reason: toolCallCount > 0 ? 'tool_calls' : 'stop',
+                                    },
+                                ],
+                                usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+                            }));
+                            emitSSE('[DONE]');
+                            closeStream();
+                        });
+                        req.on('error', (err) => {
+                            if (!streamClosed) {
+                                try {
+                                    controller.error(err);
+                                }
+                                catch {
+                                    /* already closed */
+                                }
+                            }
+                            client.close();
+                        });
+                    },
+                });
+                resolve(new Response(readable, {
+                    status: 200,
+                    headers: {
+                        'Content-Type': 'text/event-stream',
+                        'Cache-Control': 'no-cache',
+                        Connection: 'keep-alive',
+                    },
+                }));
+            });
+            req.on('error', (err) => {
+                client.close();
+                reject(err);
+            });
+            req.write(body);
+            req.end();
+        });
+    }
+    /**
+     * Parse protobuf buffer into frames and extract text/toolcalls.
+     * Shared logic between JSON and SSE transformers.
+     */
+    *parseProtobufFrames(buffer) {
+        let offset = 0;
+        while (offset < buffer.length) {
+            if (offset + 5 > buffer.length)
+                break;
+            const flags = buffer[offset];
+            const length = buffer.readUInt32BE(offset + 1);
+            if (offset + 5 + length > buffer.length)
+                break;
+            let payload = buffer.slice(offset + 5, offset + 5 + length);
+            offset += 5 + length;
+            payload = (0, cursor_stream_parser_js_1.decompressPayload)(payload, flags);
+            // Check for JSON error format
+            try {
+                const text = payload.toString('utf-8');
+                if (text.startsWith('{') && text.includes('"error"')) {
+                    yield { type: 'error', response: createErrorResponse(JSON.parse(text)) };
+                    return;
+                }
+            }
+            catch (err) {
+                if (process.env.CCS_DEBUG) {
+                    console.error('[cursor] parseProtobufFrames error parsing failed:', err);
+                }
+            }
+            const result = (0, cursor_protobuf_js_1.extractTextFromResponse)(new Uint8Array(payload));
+            // Check for protobuf-decoded error
+            if (result.error) {
+                const errorLower = result.error.toLowerCase();
+                const isRateLimit = errorLower.includes('rate limit') ||
+                    errorLower.includes('resource_exhausted') ||
+                    errorLower.includes('too many requests');
+                yield {
+                    type: 'error',
+                    response: new Response(JSON.stringify({
+                        error: {
+                            message: result.error,
+                            type: isRateLimit ? 'rate_limit_error' : 'server_error',
+                            code: isRateLimit ? 'rate_limited' : 'cursor_error',
+                        },
+                    }), {
+                        status: isRateLimit ? 429 : 400,
+                        headers: { 'Content-Type': 'application/json' },
+                    }),
+                };
+                return;
+            }
+            if (result.toolCall) {
+                yield { type: 'toolCall', toolCall: result.toolCall };
+            }
+            if (result.text) {
+                yield { type: 'text', text: result.text };
+            }
+        }
+    }
+    transformProtobufToJSON(buffer, model, _body) {
+        const responseId = `chatcmpl-cursor-${Date.now()}`;
+        const created = Math.floor(Date.now() / 1000);
+        let totalContent = '';
+        const toolCalls = [];
+        const toolCallsMap = new Map();
+        for (const frame of this.parseProtobufFrames(buffer)) {
+            if (frame.type === 'error') {
+                return frame.response;
+            }
+            if (frame.type === 'toolCall') {
+                const tc = frame.toolCall;
+                if (toolCallsMap.has(tc.id)) {
+                    const existing = toolCallsMap.get(tc.id);
+                    if (!existing)
+                        continue;
+                    existing.function.arguments += tc.function.arguments;
+                    existing.isLast = tc.isLast;
+                }
+                else {
+                    toolCallsMap.set(tc.id, {
+                        ...tc,
+                        index: toolCallsMap.size,
+                    });
+                }
+                if (tc.isLast) {
+                    const finalToolCall = toolCallsMap.get(tc.id);
+                    if (!finalToolCall)
+                        continue;
+                    toolCalls.push({
+                        id: finalToolCall.id,
+                        type: finalToolCall.type,
+                        function: {
+                            name: finalToolCall.function.name,
+                            arguments: finalToolCall.function.arguments,
+                        },
+                    });
+                }
+            }
+            if (frame.type === 'text') {
+                totalContent += frame.text;
+            }
+        }
+        // Finalize remaining tool calls
+        for (const id of Array.from(toolCallsMap.keys())) {
+            const tc = toolCallsMap.get(id);
+            if (!tc)
+                continue;
+            if (!toolCalls.find((t) => t.id === id)) {
+                toolCalls.push({
+                    id: tc.id,
+                    type: tc.type,
+                    function: {
+                        name: tc.function.name,
+                        arguments: tc.function.arguments,
+                    },
+                });
+            }
+        }
+        const message = {
+            role: 'assistant',
+            content: totalContent || null,
+        };
+        if (toolCalls.length > 0) {
+            message.tool_calls = toolCalls;
+        }
+        const completion = {
+            id: responseId,
+            object: 'chat.completion',
+            created,
+            model,
+            choices: [
+                {
+                    index: 0,
+                    message,
+                    finish_reason: toolCalls.length > 0 ? 'tool_calls' : 'stop',
+                },
+            ],
+            usage: {
+                prompt_tokens: 0,
+                completion_tokens: 0,
+                total_tokens: 0,
+            },
+        };
+        return new Response(JSON.stringify(completion), {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    }
+    /** @deprecated Use executeStreaming() for real-time SSE. Retained for fetch fallback. */
+    transformProtobufToSSE(buffer, model, _body) {
+        const responseId = `chatcmpl-cursor-${Date.now()}`;
+        const created = Math.floor(Date.now() / 1000);
+        const chunks = [];
+        const toolCalls = [];
+        const toolCallsMap = new Map();
+        for (const frame of this.parseProtobufFrames(buffer)) {
+            if (frame.type === 'error') {
+                return frame.response;
+            }
+            if (frame.type === 'toolCall') {
+                const tc = frame.toolCall;
+                if (chunks.length === 0) {
+                    chunks.push(`data: ${JSON.stringify({
+                        id: responseId,
+                        object: 'chat.completion.chunk',
+                        created,
+                        model,
+                        choices: [
+                            {
+                                index: 0,
+                                delta: { role: 'assistant', content: '' },
+                                finish_reason: null,
+                            },
+                        ],
+                    })}\n\n`);
+                }
+                if (toolCallsMap.has(tc.id)) {
+                    const existing = toolCallsMap.get(tc.id);
+                    if (!existing)
+                        continue;
+                    existing.function.arguments += tc.function.arguments;
+                    existing.isLast = tc.isLast;
+                    if (tc.function.arguments) {
+                        chunks.push(`data: ${JSON.stringify({
+                            id: responseId,
+                            object: 'chat.completion.chunk',
+                            created,
+                            model,
+                            choices: [
+                                {
+                                    index: 0,
+                                    delta: {
+                                        tool_calls: [
+                                            {
+                                                index: existing.index,
+                                                id: tc.id,
+                                                type: 'function',
+                                                function: {
+                                                    name: tc.function.name,
+                                                    arguments: tc.function.arguments,
+                                                },
+                                            },
+                                        ],
+                                    },
+                                    finish_reason: null,
+                                },
+                            ],
+                        })}\n\n`);
+                    }
+                }
+                else {
+                    const toolCallIndex = toolCalls.length;
+                    toolCalls.push({ ...tc, index: toolCallIndex });
+                    toolCallsMap.set(tc.id, { ...tc, index: toolCallIndex });
+                    chunks.push(`data: ${JSON.stringify({
+                        id: responseId,
+                        object: 'chat.completion.chunk',
+                        created,
+                        model,
+                        choices: [
+                            {
+                                index: 0,
+                                delta: {
+                                    tool_calls: [
+                                        {
+                                            index: toolCallIndex,
+                                            id: tc.id,
+                                            type: 'function',
+                                            function: {
+                                                name: tc.function.name,
+                                                arguments: tc.function.arguments,
+                                            },
+                                        },
+                                    ],
+                                },
+                                finish_reason: null,
+                            },
+                        ],
+                    })}\n\n`);
+                }
+            }
+            if (frame.type === 'text') {
+                chunks.push(`data: ${JSON.stringify({
+                    id: responseId,
+                    object: 'chat.completion.chunk',
+                    created,
+                    model,
+                    choices: [
+                        {
+                            index: 0,
+                            delta: chunks.length === 0 && toolCalls.length === 0
+                                ? { role: 'assistant', content: frame.text }
+                                : { content: frame.text },
+                            finish_reason: null,
+                        },
+                    ],
+                })}\n\n`);
+            }
+        }
+        if (chunks.length === 0 && toolCalls.length === 0) {
+            chunks.push(`data: ${JSON.stringify({
+                id: responseId,
+                object: 'chat.completion.chunk',
+                created,
+                model,
+                choices: [
+                    {
+                        index: 0,
+                        delta: { role: 'assistant', content: '' },
+                        finish_reason: null,
+                    },
+                ],
+            })}\n\n`);
+        }
+        chunks.push(`data: ${JSON.stringify({
+            id: responseId,
+            object: 'chat.completion.chunk',
+            created,
+            model,
+            choices: [
+                {
+                    index: 0,
+                    delta: {},
+                    finish_reason: toolCalls.length > 0 ? 'tool_calls' : 'stop',
+                },
+            ],
+            usage: {
+                prompt_tokens: 0,
+                completion_tokens: 0,
+                total_tokens: 0,
+            },
+        })}\n\n`);
+        chunks.push('data: [DONE]\n\n');
+        return new Response(chunks.join(''), {
+            status: 200,
+            headers: {
+                'Content-Type': 'text/event-stream',
+                'Cache-Control': 'no-cache',
+                Connection: 'keep-alive',
+            },
+        });
+    }
+}
+exports.CursorExecutor = CursorExecutor;
+exports.default = CursorExecutor;
+//# sourceMappingURL=cursor-executor.js.map