Function handleNonStream

src/handler.ts:1818–2145

(res: Response, cursorReq: CursorChatRequest, body: AnthropicRequest, log: RequestLogger, clientRequestedThinking: boolean = false)

// ==================== 非流式处理 ====================

async function handleNonStream(res: Response, cursorReq: CursorChatRequest, body: AnthropicRequest, log: RequestLogger, clientRequestedThinking: boolean = false): Promise<void> {
    // ★ 非流式保活：手动设置 chunked 响应，在缓冲期间每 15s 发送空白字符保活
    // JSON.parse 会忽略前导空白，所以客户端解析不受影响
    res.writeHead(200, { 'Content-Type': 'application/json' });
    const keepaliveInterval = setInterval(() => {
        try {
            res.write(' ');
            // @ts-expect-error flush exists on ServerResponse when compression is used
            if (typeof res.flush === 'function') res.flush();
        } catch { /* connection already closed, ignore */ }
    }, 15000);

    try {
    log.startPhase('send', '发送到 Cursor (非流式)');
    const apiStart = Date.now();
    let { text: fullText, usage: cursorUsage } = await sendCursorRequestFull(cursorReq);
    log.recordTTFT();
    log.recordCursorApiTime(apiStart);
    log.recordRawResponse(fullText);
    log.startPhase('response', '处理响应');
    const hasTools = (body.tools?.length ?? 0) > 0;
    let activeCursorReq = cursorReq;
    let retryCount = 0;

    log.info('Handler', 'response', `非流式原始响应: ${fullText.length} chars`, {
        preview: fullText.substring(0, 300),
        hasTools,
    });

    // ★ Thinking 提取（在拒绝检测之前）
    // 始终剥离 thinking 标签，避免泄漏到最终文本中
    let thinkingContent = '';
    if (hasLeadingThinking(fullText)) {
        const { thinkingContent: extracted, strippedText } = extractThinking(fullText);
        if (extracted) {
            thinkingContent = extracted;
            fullText = strippedText;
            if (clientRequestedThinking) {
                log.info('Handler', 'thinking', `非流式剥离 thinking → content block: ${thinkingContent.length} chars, 剩余 ${fullText.length} chars`);
            } else {
                log.info('Handler', 'thinking', `非流式剥离 thinking (非客户端请求): ${thinkingContent.length} chars, 剩余 ${fullText.length} chars`);
            }
        }
    }

    // 拒绝检测 + 自动重试
    // fullText 已在上方剥离 thinking 标签，可直接用于拒绝检测
    const shouldRetry = () => {
        return isRefusal(fullText) && !(hasTools && hasToolCalls(fullText));
    };

    if (shouldRetry()) {
        for (let attempt = 0; attempt < MAX_REFUSAL_RETRIES; attempt++) {
            retryCount++;
            log.warn('Handler', 'retry', `非流式检测到拒绝（第${retryCount}次重试）`, { preview: fullText.substring(0, 200) });
            log.updateSummary({ retryCount });
            const retryBody = buildRetryRequest(body, attempt);
            activeCursorReq = await convertToCursorRequest(retryBody);