@georgedong32/ccs 7.67.1 → 8.0.0

package/dist/cursor/cursor-executor.js

@@ -30,7 +30,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CursorExecutor = void 0;
 const cursor_protobuf_js_1 = require("./cursor-protobuf.js");
 const cursor_translator_js_1 = require("./cursor-translator.js");
+const cursor_protobuf_schema_js_1 = require("./cursor-protobuf-schema.js");
 const cursor_client_policy_js_1 = require("./cursor-client-policy.js");
+const logging_1 = require("../services/logging");
+const logger = (0, logging_1.createLogger)('cursor:executor');
 const cursor_stream_parser_js_1 = require("./cursor-stream-parser.js");
 /** Lazy import http2 */
 let http2Module = null;
@@ -51,23 +54,51 @@ async function getHttp2() {
 /**
  * Create error response from JSON error
  */
-function createErrorResponse(jsonError) {
+function toCursorErrorPayloadFromJson(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({
+    const mappedError = (0, cursor_stream_parser_js_1.mapCursorConnectError)(jsonError?.error?.code);
+    return {
+        message: errorMsg,
+        status: mappedError.status,
+        errorType: mappedError.errorType,
+        code: jsonError?.error?.details?.[0]?.debug?.error || 'unknown',
+    };
+}
+function buildCursorErrorEnvelope(error) {
+    return JSON.stringify({
         error: {
-            message: errorMsg,
-            type: isRateLimit ? 'rate_limit_error' : 'api_error',
-            code: jsonError?.error?.details?.[0]?.debug?.error || 'unknown',
+            message: error.message,
+            type: error.errorType,
+            code: error.code,
+            status: error.status,
         },
-    }), {
-        status: isRateLimit ? 429 : 400,
+    });
+}
+function createCursorErrorResponse(error) {
+    return new Response(buildCursorErrorEnvelope(error), {
+        status: error.status,
         headers: { 'Content-Type': 'application/json' },
     });
 }
+function toCursorExecutorErrorPayload(error) {
+    if (error instanceof cursor_stream_parser_js_1.CursorConnectFrameError) {
+        return {
+            message: error.message,
+            status: error.status,
+            errorType: error.errorType,
+            code: 'cursor_protocol_error',
+        };
+    }
+    return {
+        message: error instanceof Error ? error.message : 'Cursor streaming failed.',
+        status: 502,
+        errorType: 'server_error',
+        code: 'cursor_error',
+    };
+}
 class CursorExecutor {
     constructor() {
         this.baseUrl = 'https://api2.cursor.sh';
@@ -170,6 +201,12 @@ class CursorExecutor {
         const url = this.buildUrl();
         const headers = this.buildHeaders(credentials);
         const transformedBody = this.transformRequest(model, body, stream, credentials);
+        const startedAt = Date.now();
+        logger.stage('upstream', 'cursor.upstream.request', 'Sending Cursor upstream request', {
+            provider: 'cursor',
+            model,
+            stream,
+        });
         try {
             // Streaming requests use incremental HTTP/2 → SSE pipeline
             if (stream) {
@@ -183,6 +220,7 @@ class CursorExecutor {
                 : await this.makeFetchRequest(url, headers, transformedBody, signal);
             if (response.status !== 200) {
                 const errorText = response.body?.toString() || 'Unknown error';
+                logger.stage('cleanup', 'cursor.upstream.error', 'Cursor upstream returned non-200 status', { provider: 'cursor', model, status: response.status }, { level: 'error', latencyMs: Date.now() - startedAt });
                 const errorResponse = new Response(JSON.stringify({
                     error: {
                         message: `[${response.status}]: ${errorText}`,
@@ -196,12 +234,19 @@ class CursorExecutor {
                 return { response: errorResponse, url, headers, transformedBody: body };
             }
             const transformedResponse = this.transformProtobufToJSON(response.body, model, body);
+            logger.stage('transform', 'cursor.upstream.transformed', 'Cursor response transformed', { provider: 'cursor', model }, { latencyMs: Date.now() - startedAt });
             return { response: transformedResponse, url, headers, transformedBody: body };
         }
         catch (error) {
+            const err = error;
+            logger.stage('cleanup', 'cursor.upstream.exception', 'Cursor upstream request threw', { provider: 'cursor', model }, {
+                level: 'error',
+                latencyMs: Date.now() - startedAt,
+                error: { name: err.name, message: err.message },
+            });
             const errorResponse = new Response(JSON.stringify({
                 error: {
-                    message: error.message,
+                    message: err.message,
                     type: 'connection_error',
                     code: '',
                 },
@@ -308,156 +353,213 @@ class CursorExecutor {
                 const parser = new cursor_stream_parser_js_1.StreamingFrameParser();
                 const enc = new TextEncoder();
                 const toolCallsMap = new Map();
+                const pendingPackets = [];
                 let chunkCount = 0;
                 let toolCallCount = 0;
+                let streamResponseResolved = false;
+                const flushPendingPackets = () => {
+                    if (!streamController || pendingPackets.length === 0 || streamClosed)
+                        return;
+                    for (const packet of pendingPackets.splice(0)) {
+                        streamController.enqueue(enc.encode(packet));
+                    }
+                };
+                const queuePacket = (packet) => {
+                    if (streamClosed)
+                        return;
+                    if (streamController) {
+                        streamController.enqueue(enc.encode(packet));
+                        return;
+                    }
+                    pendingPackets.push(packet);
+                };
+                const emitSSE = (data) => {
+                    queuePacket(`data: ${data}\n\n`);
+                };
+                const emitSSEEvent = (event, data) => {
+                    queuePacket(`event: ${event}\ndata: ${data}\n\n`);
+                };
                 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 */
+                        flushPendingPackets();
+                    },
+                });
+                const resolveStreamingResponse = () => {
+                    if (streamResponseResolved || settled)
+                        return;
+                    streamResponseResolved = true;
+                    resolveOnce(new Response(readable, {
+                        status: 200,
+                        headers: {
+                            'Content-Type': 'text/event-stream',
+                            'Cache-Control': 'no-cache',
+                            Connection: 'keep-alive',
+                        },
+                    }));
+                    flushPendingPackets();
+                };
+                const closeStream = () => {
+                    if (streamClosed)
+                        return;
+                    streamClosed = true;
+                    if (streamController) {
+                        try {
+                            streamController.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 }],
+                });
+                const handleFrameError = (frame) => {
+                    const errorPayload = buildCursorErrorEnvelope({
+                        message: frame.message,
+                        status: frame.status,
+                        errorType: frame.errorType,
+                        code: frame.errorType === 'rate_limit_error' ? 'rate_limited' : 'cursor_error',
+                    });
+                    if (!streamResponseResolved && chunkCount === 0 && toolCallCount === 0) {
+                        streamClosed = true;
+                        req.close();
+                        client.close();
+                        resolveOnce(new Response(errorPayload, {
+                            status: frame.status,
+                            headers: { 'Content-Type': 'application/json' },
+                        }));
+                        return;
+                    }
+                    resolveStreamingResponse();
+                    emitSSEEvent('error', errorPayload);
+                    closeStream();
+                };
+                req.on('data', (chunk) => {
+                    if (streamClosed)
+                        return;
+                    for (const frame of parser.push(chunk)) {
+                        if (frame.type === 'error') {
+                            handleFrameError(frame);
+                            return;
+                        }
+                        resolveStreamingResponse();
+                        if (frame.type === 'toolCall') {
+                            const tc = frame.toolCall;
+                            // Emit role chunk on first content
+                            if (chunkCount === 0) {
+                                emitSSE(buildChunk({ role: 'assistant', content: '' }, null));
+                                chunkCount++;
                             }
-                            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,
-                                                    },
+                            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++;
-                                    }
-                                }
-                                if (frame.type === 'text') {
-                                    const delta = chunkCount === 0 && toolCallCount === 0
-                                        ? { role: 'assistant', content: frame.text }
-                                        : { content: frame.text };
-                                    emitSSE(buildChunk(delta, null));
-                                    chunkCount++;
-                                }
-                                if (frame.type === 'thinking') {
-                                    const delta = chunkCount === 0 && toolCallCount === 0
-                                        ? { role: 'assistant', reasoning_content: frame.text }
-                                        : { reasoning_content: frame.text };
-                                    emitSSE(buildChunk(delta, null));
+                                            },
+                                        ],
+                                    }, 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 */
-                                }
+                            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++;
                             }
-                            client.close();
-                        });
-                    },
+                        }
+                        if (frame.type === 'text') {
+                            const delta = chunkCount === 0 && toolCallCount === 0
+                                ? { role: 'assistant', content: frame.text }
+                                : { content: frame.text };
+                            emitSSE(buildChunk(delta, null));
+                            chunkCount++;
+                        }
+                        if (frame.type === 'thinking') {
+                            const delta = chunkCount === 0 && toolCallCount === 0
+                                ? { role: 'assistant', reasoning_content: frame.text }
+                                : { reasoning_content: frame.text };
+                            emitSSE(buildChunk(delta, null));
+                            chunkCount++;
+                        }
+                    }
+                });
+                req.on('end', () => {
+                    if (streamClosed)
+                        return;
+                    for (const frame of parser.finish()) {
+                        if (frame.type === 'error') {
+                            handleFrameError(frame);
+                            return;
+                        }
+                    }
+                    resolveStreamingResponse();
+                    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) => {
+                    client.close();
+                    if (!streamResponseResolved) {
+                        rejectOnce(err instanceof Error ? err : new Error(String(err)));
+                        return;
+                    }
+                    if (!streamClosed) {
+                        try {
+                            streamController?.error(err);
+                        }
+                        catch {
+                            /* already closed */
+                        }
+                    }
                 });
-                resolveOnce(new Response(readable, {
-                    status: 200,
-                    headers: {
-                        'Content-Type': 'text/event-stream',
-                        'Cache-Control': 'no-cache',
-                        Connection: 'keep-alive',
-                    },
-                }));
             });
             req.on('error', (err) => {
                 client.close();
@@ -482,12 +584,43 @@ class CursorExecutor {
                 break;
             let payload = buffer.slice(offset + 5, offset + 5 + length);
             offset += 5 + length;
-            payload = (0, cursor_stream_parser_js_1.decompressPayload)(payload, flags);
+            try {
+                payload = (0, cursor_stream_parser_js_1.decompressPayload)(payload, flags);
+            }
+            catch (error) {
+                yield { type: 'error', error: toCursorExecutorErrorPayload(error) };
+                return;
+            }
+            if ((0, cursor_protobuf_schema_js_1.isEndStreamConnectFrame)(flags)) {
+                try {
+                    const json = JSON.parse(payload.toString('utf-8'));
+                    const msg = json?.error?.details?.[0]?.debug?.details?.title ||
+                        json?.error?.details?.[0]?.debug?.details?.detail ||
+                        json?.error?.message;
+                    if (msg) {
+                        const mappedError = (0, cursor_stream_parser_js_1.mapCursorConnectError)(json?.error?.code);
+                        yield {
+                            type: 'error',
+                            error: {
+                                message: msg,
+                                status: mappedError.status,
+                                errorType: mappedError.errorType,
+                                code: json?.error?.code || 'cursor_error',
+                            },
+                        };
+                        return;
+                    }
+                }
+                catch {
+                    // Ignore successful end-stream metadata trailers.
+                }
+                continue;
+            }
             // 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)) };
+                    yield { type: 'error', error: toCursorErrorPayloadFromJson(JSON.parse(text)) };
                     return;
                 }
             }
@@ -505,16 +638,12 @@ class CursorExecutor {
                     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' },
-                    }),
+                    error: {
+                        message: result.error,
+                        status: isRateLimit ? 429 : 502,
+                        errorType: isRateLimit ? 'rate_limit_error' : 'server_error',
+                        code: isRateLimit ? 'rate_limited' : 'cursor_error',
+                    },
                 };
                 return;
             }
@@ -528,6 +657,17 @@ class CursorExecutor {
                 yield { type: 'thinking', text: result.thinking };
             }
         }
+        if (offset !== buffer.length) {
+            yield {
+                type: 'error',
+                error: {
+                    message: 'Truncated Cursor ConnectRPC frame.',
+                    status: 502,
+                    errorType: 'server_error',
+                    code: 'cursor_protocol_error',
+                },
+            };
+        }
     }
     transformProtobufToJSON(buffer, model, _body) {
         const responseId = `chatcmpl-cursor-${Date.now()}`;
@@ -538,7 +678,7 @@ class CursorExecutor {
         const toolCallsMap = new Map();
         for (const frame of this.parseProtobufFrames(buffer)) {
             if (frame.type === 'error') {
-                return frame.response;
+                return createCursorErrorResponse(frame.error);
             }
             if (frame.type === 'toolCall') {
                 const tc = frame.toolCall;
@@ -634,7 +774,18 @@ class CursorExecutor {
         const toolCallsMap = new Map();
         for (const frame of this.parseProtobufFrames(buffer)) {
             if (frame.type === 'error') {
-                return frame.response;
+                if (chunks.length === 0 && toolCalls.length === 0) {
+                    return createCursorErrorResponse(frame.error);
+                }
+                chunks.push(`event: error\ndata: ${buildCursorErrorEnvelope(frame.error)}\n\n`);
+                return new Response(chunks.join(''), {
+                    status: 200,
+                    headers: {
+                        'Content-Type': 'text/event-stream',
+                        'Cache-Control': 'no-cache',
+                        Connection: 'keep-alive',
+                    },
+                });
             }
             if (frame.type === 'toolCall') {
                 const tc = frame.toolCall;