Function executeAttempt

src/handler.ts:928–1043

()

    });

    const executeAttempt = async (): Promise<{
        rawResponse: string;
        visibleText: string;
        thinkingContent: string;
        streamer: ReturnType<typeof createIncrementalTextStreamer>;
    }> => {
        let rawResponse = '';
        let visibleText = '';
        let leadingBuffer = '';
        let leadingResolved = false;
        let thinkingContent = '';
        const attemptStreamer = createIncrementalTextStreamer({
            warmupChars: 300,   // ★ 与工具模式对齐
            transform: sanitizeResponse,
            isBlockedPrefix: (text) => isRefusal(text.substring(0, 300)),
        });

        const flushVisible = (chunk: string): void => {
            if (!chunk) return;
            visibleText += chunk;
            const delta = attemptStreamer.push(chunk);
            if (!delta) return;

            if (clientRequestedThinking && thinkingContent && !streamState.thinkingEmitted) {
                emitAnthropicThinkingBlock(res, streamState, thinkingContent);
            }
            writeAnthropicTextDelta(res, streamState, delta);
        };

        const apiStart = Date.now();
        let firstChunk = true;
        log.startPhase('send', '发送到 Cursor');

        await sendCursorRequest(activeCursorReq, (event: CursorSSEEvent) => {
            if (event.type === 'finish') {
                if (event.messageMetadata?.usage) cursorUsage = event.messageMetadata.usage;
                return;
            }
            if (event.type !== 'text-delta' || !event.delta) return;

            if (firstChunk) {
                log.recordTTFT();
                log.endPhase();
                log.startPhase('response', '接收响应');
                firstChunk = false;
            }

            rawResponse += event.delta;

            // ★ 始终缓冲前导内容以检测并剥离 <thinking> 标签
            // 无论 clientRequestedThinking 是否为 true，都需要分离 thinking
            // 区别在于：true 时发送 thinking content block，false 时静默丢弃 thinking 标签
            if (!leadingResolved) {
                leadingBuffer += event.delta;
                const split = splitLeadingThinkingBlocks(leadingBuffer);

                if (split.startedWithThinking) {
                    if (!split.complete) return;