Function handleResponsesNonStream

src/openai-handler.ts:1775–1868

* Responses API 非流式处理

(
    res: Response,
    cursorReq: CursorChatRequest,
    body: Record<string, unknown>,
    anthropicReq: AnthropicRequest,
    log: RequestLogger,
)

 * Responses API 非流式处理
 */
async function handleResponsesNonStream(
    res: Response,
    cursorReq: CursorChatRequest,
    body: Record<string, unknown>,
    anthropicReq: AnthropicRequest,
    log: RequestLogger,
): Promise<void> {
    let activeCursorReq = cursorReq;
    let fullText = (await sendCursorRequestFull(activeCursorReq)).text;
    const hasTools = (anthropicReq.tools?.length ?? 0) > 0;

    // Thinking 提取
    if (hasLeadingThinking(fullText)) {
        fullText = extractThinking(fullText).strippedText;
    }

    // 拒绝检测 + 重试
    const shouldRetry = () => isRefusal(fullText) && !(hasTools && hasToolCalls(fullText));
    if (shouldRetry()) {
        for (let attempt = 0; attempt < MAX_REFUSAL_RETRIES; attempt++) {
            const retryBody = buildRetryRequest(anthropicReq, attempt);
            const retryCursorReq = await convertToCursorRequest(retryBody);
            activeCursorReq = retryCursorReq;
            fullText = (await sendCursorRequestFull(activeCursorReq)).text;
            if (hasLeadingThinking(fullText)) {
                fullText = extractThinking(fullText).strippedText;
            }
            if (!shouldRetry()) break;
        }
        if (shouldRetry()) {
            if (isToolCapabilityQuestion(anthropicReq)) {
                fullText = CLAUDE_TOOLS_RESPONSE;
            } else {
                fullText = CLAUDE_IDENTITY_RESPONSE;
            }
        }
    }

    if (hasTools) {
        fullText = await autoContinueCursorToolResponseFull(activeCursorReq, fullText, hasTools);
    }

    fullText = sanitizeResponse(fullText);

    const respId = responsesId();
    const model = (body.model as string) || 'gpt-4';
    const inputTokens = estimateInputTokens(anthropicReq);
    const outputTokens = Math.ceil(fullText.length / 3);
    const usage = { input_tokens: inputTokens, output_tokens: outputTokens, total_tokens: inputTokens + outputTokens };

    const output: Record<string, unknown>[] = [];
    let toolCallsDetected = 0;

    if (hasTools && hasToolCalls(fullText)) {
        const { toolCalls, cleanText } = parseToolCalls(fullText);
        toolCallsDetected = toolCalls.length;
        log.recordToolCalls(toolCalls);
        log.updateSummary({ toolCallsDetected: toolCalls.length });