route-claudecode/dist/providers/gemini/modules/request-converter.js

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

"use strict";
/**
 * Gemini Request Converter Module
 * 请求格式转换器，负责Anthropic到Gemini的请求转换
 * Project owner: Jason Zhang
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.GeminiRequestConverter = void 0;
exports.convertAnthropicToGeminiRequest = convertAnthropicToGeminiRequest;
const logger_1 = require("@/utils/logger");
const gemini_1 = require("@/transformers/gemini");
/**
 * Gemini请求转换器类
 */
class GeminiRequestConverter {
    requestId;
    constructor(requestId = 'unknown') {
        this.requestId = requestId;
    }
    /**
     * 转换Anthropic请求为Gemini API格式
     */
    convertRequest(request, model) {
        try {
            logger_1.logger.debug('Converting Anthropic request to Gemini format', {
                requestId: this.requestId,
                model,
                messageCount: request.messages?.length,
                hasTools: !!request.tools?.length,
                hasSystem: !!request.metadata?.system
            });
            // 使用统一的转换器
            const { geminiRequest } = (0, gemini_1.transformAnthropicToGemini)(request);
            // 添加模型信息到转换结果
            const requestWithModel = {
                model,
                ...geminiRequest
            };
            logger_1.logger.debug('Successfully converted to Gemini format', {
                requestId: this.requestId,
                model: requestWithModel.model,
                hasContents: !!requestWithModel.contents?.length,
                hasTools: !!requestWithModel.tools?.length,
                hasToolConfig: !!requestWithModel.toolConfig,
                generationConfig: requestWithModel.generationConfig
            });
            return requestWithModel;
        }
        catch (error) {
            logger_1.logger.error('Failed to convert request to Gemini format', {
                requestId: this.requestId,
                error: error.message,
                model,
                originalModel: request.model
            });
            throw error;
        }
    }
    /**
     * 验证转换后的请求格式
     */
    validateConvertedRequest(request) {
        try {
            const isValid = (request &&
                typeof request.model === 'string' &&
                Array.isArray(request.contents) &&
                request.contents.length > 0 &&
                request.contents.every(content => content &&
                    ['user', 'model'].includes(content.role) &&
                    Array.isArray(content.parts) &&
                    content.parts.length > 0));
            if (!isValid) {
                logger_1.logger.warn('Converted Gemini request validation failed', {
                    requestId: this.requestId,
                    hasModel: !!request?.model,
                    hasContents: !!request?.contents,
                    contentsLength: request?.contents?.length
                });
            }
            return isValid;
        }
        catch (error) {
            logger_1.logger.error('Error validating converted request', {
                requestId: this.requestId,
                error: error.message
            });
            return false;
        }
    }
    /**
     * 创建包含调试信息的转换结果
     */
    createConversionResult(geminiRequest) {
        return {
            request: geminiRequest,
            debug: {
                requestId: this.requestId,
                timestamp: Date.now(),
                hasTools: !!geminiRequest.tools?.length,
                hasSystem: geminiRequest.contents?.some(c => c.parts?.some(p => p.text?.startsWith('System:'))) || false,
                contentCount: geminiRequest.contents?.length || 0
            }
        };
    }
}
exports.GeminiRequestConverter = GeminiRequestConverter;
/**
 * 便捷函数：转换请求并返回验证结果
 */
function convertAnthropicToGeminiRequest(request, model, requestId = 'unknown') {
    const converter = new GeminiRequestConverter(requestId);
    const geminiRequest = converter.convertRequest(request, model);
    if (!converter.validateConvertedRequest(geminiRequest)) {
        throw new Error('Converted Gemini request failed validation');
    }
    return geminiRequest;
}
//# sourceMappingURL=request-converter.js.map