route-claudecode/dist/utils/pure-openai-api-handler.js

Advanced routing and transformation system for Claude Code outputs to multiple AI providers

"use strict";
/**
 * 纯净OpenAI API处理器 - 遵循跨节点耦合约束
 * 项目所有者: Jason Zhang
 *
 * 只负责纯粹的OpenAI API调用，不包含任何transformer逻辑
 * Transformer转换应在Provider外部完成
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.PureOpenAIAPIHandler = void 0;
exports.createPureAPIHandler = createPureAPIHandler;
const logger_1 = require("@/utils/logger");
/**
 * 纯净的OpenAI API处理类 - 零跨节点耦合
 * 假设接收的请求已经是OpenAI格式，返回原始OpenAI响应
 */
class PureOpenAIAPIHandler {
    config;
    constructor(config) {
        this.config = config;
    }
    /**
     * 纯净的非流式API调用 - 假设请求已转换为OpenAI格式
     */
    async callAPI(openaiRequest, requestId) {
        try {
            logger_1.logger.debug('Pure OpenAI API call', {
                model: openaiRequest.model,
                hasTools: !!(openaiRequest.tools && openaiRequest.tools.length > 0),
                messageCount: openaiRequest.messages?.length || 0,
                requestId,
                provider: this.config.providerName
            }, requestId, 'pure-api-handler');
            // 🎯 纯粹的OpenAI API调用，不做任何转换
            const rawResponse = await this.config.openaiClient.chat.completions.create(openaiRequest);
            logger_1.logger.debug('Pure OpenAI API response received', {
                responseId: rawResponse.id,
                model: rawResponse.model,
                hasChoices: !!(rawResponse.choices && rawResponse.choices.length > 0),
                requestId,
                provider: this.config.providerName
            }, requestId, 'pure-api-handler');
            return rawResponse;
        }
        catch (error) {
            logger_1.logger.error('Pure OpenAI API call failed', {
                error: error instanceof Error ? error.message : String(error),
                provider: this.config.providerName,
                model: openaiRequest?.model,
                requestId
            }, requestId, 'pure-api-handler');
            throw error;
        }
    }
    /**
     * 纯净的流式API调用 - 假设请求已转换为OpenAI格式
     */
    async *callStreamingAPI(openaiRequest, requestId) {
        try {
            openaiRequest.stream = true; // 确保流式标志
            logger_1.logger.debug('Pure OpenAI streaming API call', {
                model: openaiRequest.model,
                hasTools: !!(openaiRequest.tools && openaiRequest.tools.length > 0),
                requestId,
                provider: this.config.providerName
            }, requestId, 'pure-api-handler');
            // 🎯 纯粹的流式OpenAI API调用
            const stream = await this.config.openaiClient.chat.completions.create(openaiRequest);
            for await (const chunk of stream) {
                // 直接传递原始chunk，不做任何转换
                yield chunk;
            }
            logger_1.logger.debug('Pure OpenAI streaming completed', {
                requestId,
                provider: this.config.providerName
            }, requestId, 'pure-api-handler');
        }
        catch (error) {
            logger_1.logger.error('Pure OpenAI streaming API call failed', {
                error: error instanceof Error ? error.message : String(error),
                provider: this.config.providerName,
                model: openaiRequest?.model,
                requestId
            }, requestId, 'pure-api-handler');
            throw error;
        }
    }
    /**
     * 获取provider名称
     */
    get providerName() {
        return this.config.providerName;
    }
}
exports.PureOpenAIAPIHandler = PureOpenAIAPIHandler;
/**
 * 创建纯净API处理器
 */
function createPureAPIHandler(config) {
    return new PureOpenAIAPIHandler(config);
}
//# sourceMappingURL=pure-openai-api-handler.js.map