@dofe/infra-clients 0.1.17 → 0.1.18

package/dist/internal/volcengine-tts/volcengine-tts.client.js

@@ -1,690 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VolcengineTtsClient = void 0;
-const common_1 = require("@nestjs/common");
-const config_1 = require("@nestjs/config");
-const axios_1 = require("@nestjs/axios");
-const nest_winston_1 = require("nest-winston");
-const winston_1 = require("winston");
-const rxjs_1 = require("rxjs");
-const tos_sdk_1 = require("@volcengine/tos-sdk");
-const music_metadata_1 = require("music-metadata");
-const openapi_1 = require("@volcengine/openapi");
-const infra_common_1 = require("@dofe/infra-common");
-const infra_common_2 = require("@dofe/infra-common");
-const infra_shared_services_1 = require("@dofe/infra-shared-services");
-const infra_utils_1 = require("@dofe/infra-utils");
-/**
- * Volcengine TTS服务
- * 基于字节跳动TTS API实现语音合成功能
- */
-const hotList = [
-    'ICL_zh_male_BV144_paoxiaoge_v1_tob',
-    'zh_male_sunwukong_mars_bigtts',
-    'zh_male_xionger_mars_bigtts',
-    'zh_male_zhubajie_mars_bigtts',
-];
-let VolcengineTtsClient = class VolcengineTtsClient {
-    configService;
-    httpService;
-    fileApi;
-    logger;
-    ttsConfig;
-    ttsUrl;
-    tosClient = null;
-    cloudUrl = '';
-    constructor(configService, httpService, fileApi, logger) {
-        this.configService = configService;
-        this.httpService = httpService;
-        this.fileApi = fileApi;
-        this.logger = logger;
-        const config = (0, infra_common_1.getKeysConfig)()?.tts;
-        // console.log('techwu config', config);
-        if (!config || !config.volcengine) {
-            throw new infra_common_2.FeatureNotConfiguredError('tts', 'keys.tts');
-        }
-        const volcengineConfig = config.volcengine;
-        const storageConfig = (0, infra_common_1.getKeysConfig)()?.storage?.tos;
-        // 从 buckets 配置中读取 TOS bucket 信息
-        const bucketConfigs = this.configService.getOrThrow('buckets');
-        const tosBucket = bucketConfigs.find((b) => b.vendor === 'tos' && b.bucket === volcengineConfig.bucket);
-        if (!tosBucket) {
-            throw new Error(`TOS bucket "${volcengineConfig.bucket}" not found in buckets configuration`);
-        }
-        if (!storageConfig ||
-            !storageConfig.accessKey ||
-            !storageConfig.secretKey) {
-            throw new Error('TOS storage credentials not found in keys/config.json');
-        }
-        // 构建 TOS 配置
-        const tosConfig = {
-            region: tosBucket.region || 'cn-shanghai',
-            endpoint: this.extractTosEndpoint(tosBucket.tosEndpoint || tosBucket.endpoint),
-            bucket: tosBucket.bucket,
-            accessKeyId: storageConfig.accessKey,
-            accessKeySecret: storageConfig.secretKey,
-        };
-        this.ttsConfig = {
-            endpoint: volcengineConfig.endpoint ||
-                'https://openspeech.bytedance.com/api/v3/tts/unidirectional',
-            apiKey: volcengineConfig.apiKey || '',
-            resourceId: volcengineConfig.resourceId || '',
-            region: volcengineConfig.region || 'cn-shanghai',
-            accessKey: volcengineConfig.accessKey || '',
-            secretKey: volcengineConfig.secretKey || '',
-            tos: tosConfig,
-        };
-        this.ttsUrl = this.ttsConfig.endpoint;
-        this.validateConfiguration();
-        this.initializeTOS();
-    }
-    /**
-     * 从 endpoint URL 中提取 TOS endpoint 域名
-     * 例如: https://tos-s3-cn-shanghai.volces.com -> tos-s3-cn-shanghai.volces.com
-     */
-    extractTosEndpoint(endpointUrl) {
-        if (!endpointUrl) {
-            return 'tos-cn-shanghai.volces.com';
-        }
-        // 移除协议前缀
-        return endpointUrl.replace(/^https?:\/\//, '').replace(/\/$/, '');
-    }
-    /**
-     * 初始化火山云TOS客户端
-     */
-    initializeTOS() {
-        if (!this.ttsConfig.tos) {
-            this.logger.warn('火山云TOS配置未提供，云存储功能将无法使用');
-            return;
-        }
-        try {
-            const { region, endpoint, bucket, accessKeyId, accessKeySecret } = this.ttsConfig.tos;
-            if (!accessKeyId || !accessKeySecret) {
-                this.logger.warn('火山云TOS配置不完整，云存储功能可能无法使用');
-                this.tosClient = null;
-                return;
-            }
-            this.cloudUrl = `https://${bucket}.${endpoint}`;
-            this.tosClient = new tos_sdk_1.TosClient({
-                region,
-                endpoint,
-                accessKeyId,
-                accessKeySecret,
-            });
-            if (infra_utils_1.environmentUtil.isProduction()) {
-                this.logger.info('VolcengineTtsClient module initialized TOS client', {
-                    region,
-                    endpoint,
-                    bucket,
-                    accessKeyId,
-                    accessKeySecret,
-                });
-            }
-            else {
-                this.logger.debug('VolcengineTtsClient module initialized TOS client', {
-                    region,
-                    endpoint,
-                    bucket,
-                    accessKeyId,
-                    accessKeySecret,
-                });
-            }
-        }
-        catch (error) {
-            this.logger.error(`火山云TOS客户端初始化失败: ${error.message}`);
-            this.tosClient = null;
-        }
-    }
-    /**
-     * 验证配置信息
-     */
-    validateConfiguration() {
-        const missingVars = [];
-        if (!this.ttsConfig.apiKey) {
-            missingVars.push('apiKey');
-        }
-        if (!this.ttsConfig.resourceId) {
-            missingVars.push('resourceId');
-        }
-        if (missingVars.length > 0) {
-            this.logger.warn(`缺少TTS配置项: ${missingVars.join(', ')}`);
-            this.logger.warn('TTS服务可能无法正常工作，请检查配置文件');
-        }
-        else {
-            if (infra_utils_1.environmentUtil.isProduction()) {
-                this.logger.info('TTS configuration validated successfully');
-            }
-        }
-    }
-    /**
-     * 安全解析JSON数据
-     */
-    safeJsonParse(jsonString) {
-        try {
-            return JSON.parse(jsonString);
-        }
-        catch (error) {
-            this.logger.debug(`JSON解析失败: ${error.message}, 数据: ${jsonString.substring(0, 50)}...`);
-            return null;
-        }
-    }
-    /**
-     * 获取音频时长（毫秒）
-     */
-    async getAudioDuration(audioData) {
-        try {
-            const metadata = await (0, music_metadata_1.parseBuffer)(audioData, {
-                mimeType: 'audio/mpeg',
-            });
-            return (metadata.format.duration || 0) * 1000; // 转换为毫秒
-        }
-        catch (error) {
-            this.logger.warn(`获取音频时长失败: ${error.message}`);
-            return 0;
-        }
-    }
-    /**
-     * 直接上传音频数据到火山云TOS
-     */
-    async uploadAudioToCloud(audioData, fileName) {
-        try {
-            this.logger.info(`开始上传音频数据到火山云TOS: ${fileName}`);
-            if (!this.tosClient || !this.ttsConfig.tos) {
-                throw new Error('火山云TOS客户端未初始化');
-            }
-            // 生成TOS对象键
-            const objectKey = `tts/${Date.now()}/${fileName}`;
-            // 上传到火山云TOS
-            await this.tosClient.putObject({
-                bucket: this.ttsConfig.tos.bucket,
-                key: objectKey,
-                body: audioData,
-                contentType: 'audio/mpeg',
-            });
-            return {
-                success: true,
-                cloudUrl: `${this.cloudUrl}/${objectKey}`,
-                s3Uri: `tos://${this.ttsConfig.tos.bucket}/${objectKey}`,
-            };
-        }
-        catch (error) {
-            this.logger.error(`上传音频数据到火山云TOS失败: ${error.message}`);
-            return {
-                success: false,
-                error: error.message,
-            };
-        }
-    }
-    /**
-     * 语音合成主方法
-     */
-    async textToSpeech(request) {
-        try {
-            // 构建请求头
-            const headers = this.buildHeaders();
-            // 构建请求体
-            const payload = {
-                req_params: {
-                    text: request.text,
-                    model: 'seed-tts-1.1',
-                    speaker: request.speaker ||
-                        (await this.getRandomVoice('🔥热门推荐')).voice.id ||
-                        'zh_male_beijingxiaoye_emo_v2_mars_bigtts',
-                    additions: JSON.stringify({
-                        disable_markdown_filter: true,
-                        enable_language_detector: true,
-                        enable_latex_tn: true,
-                        disable_default_bit_rate: true,
-                        max_length_to_filter_parenthesis: 0,
-                        cache_config: {
-                            text_type: 1,
-                            use_cache: true,
-                        },
-                        post_process: {
-                            pitch: request.pitch || 0,
-                        },
-                    }),
-                    audio_params: {
-                        format: 'mp3',
-                        sample_rate: 32000,
-                        speech_rate: request.speech_rate || 0,
-                        loudness_rate: request.loudness_rate || 0,
-                    },
-                },
-            };
-            // 执行TTS请求
-            const result = await this.executeTtsRequest(headers, payload);
-            this.logger.info(`TTS合成完成，云存储URL: ${result.audio}`);
-            return { ...result, text: request.text };
-        }
-        catch (error) {
-            this.logger.error(`TTS合成失败: ${error.message}`, error.stack);
-            return {
-                success: false,
-                error: error.message,
-            };
-        }
-    }
-    /**
-     * 构建请求头
-     */
-    buildHeaders() {
-        return {
-            'x-api-key': this.ttsConfig.apiKey,
-            'X-Api-Resource-Id': this.ttsConfig.resourceId,
-            Connection: 'keep-alive',
-            'Content-Type': 'application/json',
-        };
-    }
-    /**
-     * 执行TTS请求
-     */
-    async executeTtsRequest(headers, payload) {
-        try {
-            this.logger.info('发送TTS请求到字节跳动API');
-            const response = await (0, rxjs_1.firstValueFrom)(this.httpService.post(this.ttsUrl, payload, {
-                headers,
-                responseType: 'stream',
-            }));
-            // 获取日志ID
-            const logId = response.headers['x-tt-logid'];
-            this.logger.info(`请求日志ID: ${logId}`);
-            // 处理流式响应
-            return await this.processStreamResponse(response.data, logId);
-        }
-        catch (error) {
-            this.logger.error(`TTS API请求失败: ${error.message}`);
-            if (error.response) {
-                this.logger.error('响应状态:', error.response.status);
-                this.logger.error('响应头:', error.response.headers);
-                this.logger.error('响应数据:', error.response.data);
-            }
-            throw new common_1.BadGatewayException(`TTS API请求失败: ${error.message}`);
-        }
-    }
-    /**
-     * 处理流式响应
-     */
-    async processStreamResponse(stream, logId) {
-        return new Promise((resolve, reject) => {
-            let audioData = Buffer.alloc(0);
-            let totalAudioSize = 0;
-            let hasError = false;
-            let errorMessage = '';
-            let buffer = ''; // 用于缓存不完整的数据
-            stream.on('data', (chunk) => {
-                try {
-                    // 将新数据添加到缓冲区
-                    buffer += chunk.toString();
-                    // 按行分割数据
-                    const lines = buffer.split('\n');
-                    // 保留最后一个可能不完整的行
-                    buffer = lines.pop() || '';
-                    for (const line of lines) {
-                        if (!line.trim())
-                            continue;
-                        const data = this.safeJsonParse(line);
-                        if (!data) {
-                            continue;
-                        }
-                        // 处理音频数据
-                        if (data.code === 0 && data.data) {
-                            const audioChunk = Buffer.from(data.data, 'base64');
-                            audioData = Buffer.concat([audioData, audioChunk]);
-                            totalAudioSize += audioChunk.length;
-                            continue;
-                        }
-                        // 处理句子信息
-                        if (data.code === 0 && data.sentence) {
-                            continue;
-                        }
-                        // 处理完成信号
-                        if (data.code === 20000000) {
-                            this.logger.info('TTS合成完成');
-                            break;
-                        }
-                        // 处理错误
-                        if (data.code > 0) {
-                            hasError = true;
-                            errorMessage = data.message || `错误码: ${data.code}`;
-                            this.logger.error(`TTS API错误: ${errorMessage}`);
-                            break;
-                        }
-                    }
-                }
-                catch (parseError) {
-                    this.logger.error(`解析响应数据失败: ${parseError.message}`);
-                }
-            });
-            stream.on('end', async () => {
-                this.logger.info(`流式响应结束，总音频大小: ${totalAudioSize} bytes`);
-                // 处理缓冲区中剩余的数据
-                if (buffer.trim()) {
-                    this.logger.debug(`处理缓冲区剩余数据: ${buffer.substring(0, 100)}...`);
-                    const data = this.safeJsonParse(buffer);
-                    if (data) {
-                        // 处理音频数据
-                        if (data.code === 0 && data.data) {
-                            const audioChunk = Buffer.from(data.data, 'base64');
-                            audioData = Buffer.concat([audioData, audioChunk]);
-                            totalAudioSize += audioChunk.length;
-                            this.logger.debug(`收到缓冲区音频数据块，大小: ${audioChunk.length} bytes`);
-                        }
-                        // 处理完成信号
-                        if (data.code === 20000000) {
-                            this.logger.info('TTS合成完成（缓冲区）');
-                        }
-                        // 处理错误
-                        if (data.code > 0) {
-                            hasError = true;
-                            errorMessage = data.message || `错误码: ${data.code}`;
-                            this.logger.error(`TTS API错误（缓冲区）: ${errorMessage}`);
-                        }
-                    }
-                }
-                if (hasError) {
-                    this.logger.error(`TTS处理过程中发生错误: ${errorMessage}`);
-                    resolve({
-                        success: false,
-                        error: errorMessage,
-                    });
-                    return;
-                }
-                if (audioData.length === 0) {
-                    this.logger.warn('未收到任何音频数据');
-                    resolve({
-                        success: false,
-                        error: '未收到音频数据',
-                    });
-                    return;
-                }
-                this.logger.info(`准备上传音频数据到云存储，大小: ${audioData.length} bytes`);
-                // 生成文件名
-                const fileName = `tts_${Date.now()}_${logId || 'unknown'}.mp3`;
-                const audioDuration = await this.getAudioDuration(audioData);
-                // 直接上传到云存储
-                this.uploadAudioToCloud(audioData, fileName)
-                    .then((cloudResult) => {
-                    if (cloudResult.success) {
-                        this.logger.info('音频数据上传到云存储成功');
-                        resolve({
-                            success: true,
-                            audio: cloudResult.cloudUrl,
-                            duration: audioDuration,
-                        });
-                    }
-                    else {
-                        this.logger.error(`云存储上传失败: ${cloudResult.error}`);
-                        resolve({
-                            success: false,
-                            error: cloudResult.error,
-                        });
-                    }
-                })
-                    .catch((error) => {
-                    this.logger.error(`云存储上传异常: ${error.message}`);
-                    resolve({
-                        success: false,
-                        error: error.message,
-                    });
-                });
-            });
-            stream.on('error', (error) => {
-                this.logger.error(`流处理错误: ${error.message}`);
-                reject(error);
-            });
-        });
-    }
-    /**
-     * 获取音色列表
-     */
-    async getVoiceList() {
-        const result = await this.voiceList();
-        // 统计总的声音数量
-        let totalVoices = 0;
-        const voiceIds = new Set();
-        result.forEach((category) => {
-            category.groups.forEach((group) => {
-                // 统计声音ID
-                group.items.forEach((item) => {
-                    voiceIds.add(item.id);
-                    totalVoices++;
-                });
-            });
-        });
-        return result;
-    }
-    /**
-     * 随机获取一个音色
-     */
-    async getRandomVoice(category, gender) {
-        const voiceData = await this.voiceList();
-        // 如果指定了分类，先过滤出该分类的数据
-        let filteredData = voiceData;
-        if (category) {
-            filteredData = voiceData.filter((item) => item.Category === category);
-            if (filteredData.length === 0) {
-                throw new Error(`未找到分类 "${category}" 的音色数据`);
-            }
-        }
-        // 收集所有可用的音色
-        const allVoices = [];
-        filteredData.forEach((categoryItem) => {
-            categoryItem.groups.forEach((group) => {
-                // 如果指定了性别，只收集该性别的音色
-                if (gender && group.gender_type !== gender) {
-                    return;
-                }
-                allVoices.push({
-                    ...group,
-                    category: categoryItem.Category,
-                });
-            });
-        });
-        if (allVoices.length === 0) {
-            throw new Error('没有可用的音色数据');
-        }
-        // 随机选择一个性别分组
-        const randomGroup = allVoices[Math.floor(Math.random() * allVoices.length)];
-        // 从该分组中随机选择一个音色
-        const randomVoice = randomGroup.items[Math.floor(Math.random() * randomGroup.items.length)];
-        return {
-            category: randomGroup.category,
-            gender_title: randomGroup.gender_title,
-            gender_type: randomGroup.gender_type,
-            voice: randomVoice,
-        };
-    }
-    /**
-     * 获取音色列表（原始数据）
-     */
-    async voiceList() {
-        const list = await this.volcengineApi({
-            params: {
-                Action: 'ListBigModelTTSTimbres',
-                Version: '2025-05-20',
-            },
-            body: {},
-            method: 'POST',
-            Service: 'speech_saas_prod',
-        }).then((res) => {
-            return res.Result?.Timbres ?? [];
-        });
-        // 用于存储按分类和性别分组的数据
-        const categoryMap = new Map();
-        // 遍历所有声音数据
-        list.forEach((speaker) => {
-            const speakerId = speaker.SpeakerID;
-            speaker.TimbreInfos.forEach((timbre) => {
-                const gender = timbre.Gender;
-                const speakerName = timbre.SpeakerName;
-                // 检查是否包含"多语种"分类，如果有则跳过整个声音
-                const hasMultiLanguage = timbre.Categories.some((categoryInfo) => categoryInfo.Category === '多语种');
-                if (hasMultiLanguage) {
-                    return; // 跳过包含"多语种"分类的声音
-                }
-                // 遍历每个声音的分类
-                timbre.Categories.forEach((categoryInfo) => {
-                    const category = categoryInfo.Category;
-                    // 如果分类不存在，创建新的分类，并初始化男女两个性别分组
-                    if (!categoryMap.has(category)) {
-                        categoryMap.set(category, {
-                            Category: category,
-                            groups: [
-                                {
-                                    gender_title: '女声',
-                                    gender_type: 'female',
-                                    items: [],
-                                },
-                                {
-                                    gender_title: '男声',
-                                    gender_type: 'male',
-                                    items: [],
-                                },
-                            ],
-                        });
-                    }
-                    const categoryData = categoryMap.get(category);
-                    // 根据性别找到对应的分组
-                    const genderGroup = categoryData.groups.find((group) => (gender === '女' && group.gender_type === 'female') ||
-                        (gender === '男' && group.gender_type === 'male'));
-                    if (genderGroup) {
-                        // 遍历情感信息，获取演示URL
-                        timbre.Emotions.forEach((emotion) => {
-                            // 检查是否已存在相同的声音项（避免重复）
-                            const existingItem = genderGroup.items.find((item) => item.id === speakerId && item.voice_url === emotion.DemoURL);
-                            if (!existingItem) {
-                                genderGroup.items.push({
-                                    id: speakerId,
-                                    name: speakerName,
-                                    voice_url: emotion.DemoURL,
-                                    emotion: emotion.Emotion,
-                                    emotion_type: emotion.EmotionType,
-                                    demo_text: emotion.DemoText,
-                                });
-                            }
-                        });
-                    }
-                });
-            });
-        });
-        // 转换为数组格式
-        const result = Array.from(categoryMap.values());
-        // 创建热门分组
-        const hotGroup = this.createHotGroup(list);
-        // 将热门分组添加到结果数组的开头
-        return [hotGroup, ...result];
-    }
-    /**
-     * 创建热门分组
-     */
-    createHotGroup(list) {
-        const hotItems = [];
-        // 遍历所有声音数据，筛选出热门音色
-        list.forEach((speaker) => {
-            const speakerId = speaker.SpeakerID;
-            speaker.TimbreInfos.forEach((timbre) => {
-                const gender = timbre.Gender;
-                const speakerName = timbre.SpeakerName;
-                // 检查是否包含"多语种"分类，如果有则跳过
-                const hasMultiLanguage = timbre.Categories.some((categoryInfo) => categoryInfo.Category === '多语种');
-                if (hasMultiLanguage) {
-                    return;
-                }
-                // 检查是否在热门列表中
-                const isHot = hotList.includes(speakerId);
-                if (!isHot) {
-                    return;
-                }
-                // 遍历情感信息，获取演示URL
-                timbre.Emotions.forEach((emotion) => {
-                    // 检查是否已存在相同的声音项（避免重复）
-                    const existingItem = hotItems.find((item) => item.id === speakerId && item.voice_url === emotion.DemoURL);
-                    if (!existingItem) {
-                        hotItems.push({
-                            id: speakerId,
-                            name: speakerName,
-                            voice_url: emotion.DemoURL,
-                            emotion: emotion.Emotion,
-                            emotion_type: emotion.EmotionType,
-                            demo_text: emotion.DemoText,
-                            gender: gender === '女' ? 'female' : 'male',
-                            gender_title: gender === '女' ? '女声' : '男声',
-                        });
-                    }
-                });
-            });
-        });
-        // 按照 hotList 的顺序排序热门音色
-        const sortedHotItems = hotItems.sort((a, b) => {
-            const indexA = hotList.indexOf(a.id);
-            const indexB = hotList.indexOf(b.id);
-            return indexA - indexB;
-        });
-        return {
-            Category: '🔥热门推荐',
-            groups: [
-                {
-                    gender_title: '热门音色',
-                    gender_type: 'hot',
-                    items: sortedHotItems,
-                },
-            ],
-        };
-    }
-    /**
-     * 调用火山引擎 API
-     */
-    async volcengineApi({ body = {}, params, method = 'POST', Service, }) {
-        const baseUrl = 'https://open.volcengineapi.com';
-        const openApiRequestData = {
-            region: this.ttsConfig.region,
-            method,
-            params: params,
-            headers: {},
-            body: JSON.stringify(body),
-        };
-        const signer = new openapi_1.Signer(openApiRequestData, Service);
-        // 签名
-        signer.addAuthorization({
-            accessKeyId: this.ttsConfig.accessKey,
-            secretKey: this.ttsConfig.secretKey,
-        });
-        try {
-            const response = await (0, rxjs_1.firstValueFrom)(this.httpService.request({
-                url: baseUrl,
-                headers: openApiRequestData.headers,
-                params: openApiRequestData.params,
-                method: openApiRequestData.method,
-                data: body,
-            }));
-            return response.data;
-        }
-        catch (error) {
-            this.logger.error(`火山引擎API调用失败: ${error.message}`);
-            return undefined;
-        }
-    }
-};
-exports.VolcengineTtsClient = VolcengineTtsClient;
-exports.VolcengineTtsClient = VolcengineTtsClient = __decorate([
-    (0, common_1.Injectable)(),
-    __param(3, (0, common_1.Inject)(nest_winston_1.WINSTON_MODULE_PROVIDER)),
-    __metadata("design:paramtypes", [config_1.ConfigService,
-        axios_1.HttpService,
-        infra_shared_services_1.FileStorageService,
-        winston_1.Logger])
-], VolcengineTtsClient);
-//# sourceMappingURL=volcengine-tts.client.js.map